कैसे मॉडल का उपयोग करें

अधिकांश रेल परियोजनाओं में, कोड की मुख्य एकाग्रता मॉडल पर आती है। हर कोई शायद स्लिम नियंत्रकों और वसा मॉडल के बारे में पढ़ता है और जितना संभव हो उतने मॉडल में चमकाने की कोशिश करता है, और जितना संभव हो कम नियंत्रकों में। खैर, यह सराहनीय है, हालांकि, मॉडल को मोटा करने के प्रयास में, कई अक्सर DRY सिद्धांत के बारे में भूल जाते हैं - न (कमबख्त) खुद को दोहराएं।

मैं मॉडल क्षेत्र में मछली खाने के बारे में संक्षेप में वर्णन करने की कोशिश करूंगा, और DRY के बारे में नहीं भूलूंगा।



तो, हमारे पास जो मॉडल है वह कट क्लास है। किसी भी कट क्लास की तरह, एक मॉडल में तीन चीजें होती हैं:

1) उदाहरण के तरीकों की परिभाषा

class User < ActiveRecord::Base def name [ first_name, last_name ].filter(&:presence).compact.map(&:strip) * ' ' end end 

2) वर्ग विधि परिभाषाएँ

 class User < ActiveRecord::Base def self.find_old where('created_at < ?', 1.year.ago).all end end 

3) "क्लास" कोड

 class User < ActiveRecord::Base attr_accessor :foo has_many :authentications, :dependent => :destroy has_many :invitees, :class_name => 'User', :as => :invited_by delegate :city, :country, :to => :location attr_accessible :admin, :banned, :as => :admin mount_uploader :userpic, UserPicUploader scope :admin, where(:admin => true) validates :username, :uniqueness => true, :format => /^[az][az\d_-]+$/, :length => { :within => 3..20 }, :exclusion => { :in => USERNAME_EXCLUSION } end 

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

तरीकों

इसलिए, उदाहरण के तरीकों की परिभाषा के साथ, सब कुछ यथासंभव सरल और स्पष्ट है:

 # user_stuff.rb module UserStuff def name [ first_name, last_name ].filter(&:presence).compact.map(&:strip) * ' ' end end # user.rb class User < ActiveRecord::Base include UserStuff end 

कक्षा के तरीके थोड़े अधिक दिलचस्प हैं। यह काम नहीं करता है:

 # user_stuff.rb module UserStuff def self.find_old where('created_at < ?', 1.year.ago).all end end # user.rb class User < ActiveRecord::Base include UserStuff end 

यहां हम find_old मॉड्यूल के लिए find_old पद्धति को परिभाषित करते हैं, और यह मॉडल में समाप्त नहीं होगा।
इसलिए, आपको ऐसा कुछ करने की आवश्यकता है:

 # user_stuff.rb module UserStuff def find_old where('created_at < ?', 1.year.ago).all end end # user.rb class User < ActiveRecord::Base extend UserStuff # ,  include,  extend end 

एक साथ, इंटेन्स और क्लास के तरीकों को एक मॉड्यूल में रखा जा सकता है, उदाहरण के लिए, इस तरह:

 # user_stuff.rb module UserStuff module InstanceMethods def name [ first_name, last_name ].filter(&:presence).compact.map(&:strip) * ' ' end end module ClassMethods def find_old where('created_at < ?', 1.year.ago).all end end end # user.rb class User < ActiveRecord::Base include UserStuff::InstanceMethods extend UserStuff::ClassMethods end 

कक्षा कोड

अनसुलझे सवाल "वर्ग" कोड के साथ क्या करना है। आमतौर पर वह सिर्फ सबसे ज्यादा होता है और उसे सबसे ज्यादा बार DRYing की जरूरत होती है।

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

मॉड्यूल ऑब्जेक्ट में एक सम्मिलित विधि होती है, जिसे हर बार हम मॉड्यूल को कहीं न कहीं शामिल करते हैं। इस प्रकार, हम इस मामले के तहत कोड को लागू करने के लिए मजबूर कर सकते हैं। इस तरह:

 module UserValidations def self.included(base) # base    — ,   . base.instance_eval do #     base #      validates :username, :uniqueness => true, :format => /^[az][az\d_-]+$/, :length => { :within => 3..20 }, :exclusion => { :in => USERNAME_EXCLUSION } validates :gender, :allow_blank => true, :inclusion => { :in => %w(mf) } end end end 

अब सभी सत्यापन कोड को उस समय निष्पादित नहीं किया जाएगा, जब तक कि मॉड्यूल को परिभाषित नहीं किया जाता है, लेकिन चुपचाप लेटे रहेंगे और तब तक इंतजार करेंगे जब तक हम इस मॉड्यूल को निष्क्रिय नहीं कर देते।

सभी एक झुंड में

अब यह कैसे विधि परिभाषाओं के साथ जोड़ा जाएगा जो ऊपर थे? और यहाँ है कैसे:

 # user_stuff.rb module UserStuff def self.included(base) #     base.extend ClassMethods #    # Module#include —  .          #      base.include(InstanceMethods),    : base.send :include, InstanceMethods #       base.instance_eval do validates :gender, :presence => true end end #   module ClassMethods def find_old where('created_at < ?', 1.year.ago).all end end # - module InstanceMethods def name [ first_name, last_name ].filter(&:presence).compact.map(&:strip) * ' ' end end end # user.rb class User < ActiveRecord::Base include UserStuff end 

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

आप सुंदर हो सकते हैं!

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

इस ActiveSupport::Concern का उपयोग करना ActiveSupport::Concern करना ActiveSupport::Concern हमारा कोड इस तरह से फिर से लिखा जा सकता है:

 module UserStuff extend ActiveSupport::Concern included do validates :gender, :presence => true end #   module ClassMethods def find_old where('created_at < ?', 1.year.ago).all end end # - module InstanceMethods def name [ first_name, last_name ].filter(&:presence).compact.map(&:strip) * ' ' end end end 

वास्तव में, एक अधिक सुंदर कोड इस सहायक की एकमात्र विशेषता नहीं है। उसके पास अभी भी कुछ उपयोगी विशेषताएं हैं, लेकिन मैं किसी दिन उनके बारे में अलग से लिख सकता हूं। जो इंतजार नहीं कर सकता है, उसे lib/active_support/concern.rb में कच्चे active_support पढ़ने के लिए जाने दें। आरबी कोड उदाहरणों और सभी के साथ बहुत ही शांत और वजनदार टिप्पणियां हैं।

इसे कहां रखा जाए?

एक और महत्वपूर्ण बिंदु जो प्रोग्रामर तुरंत मुठभेड़ करेगा, जिसने पहली बार अपने मॉडल को अलग-अलग मॉड्यूल में फाड़ने का फैसला किया - कोड कहां रखा जाए और मॉड्यूल का नाम कैसे दिया जाए?

संभवत: कोई असंदिग्ध राय नहीं होगी, लेकिन खुद के लिए मैं निम्नलिखित योजना के साथ आया हूं:

 # lib/models/validations.rb module Models module Validations #   c     end end # lib/models/user/validation.rb module Models module User module Validations #    User end end end # app/models/user.rb class User < ActiveRecord::Base include Models::Validations include Models::User::Validations end 

फ़ाइल नाम मायने रखते हैं क्योंकि वे आपको एक ही बार में सभी कोड लोड नहीं करने देते हैं, और रेल ऑटोलैड का उपयोग करते हैं - एक ऐसा तंत्र जब यह एक अपरिभाषित स्थिर का सामना करता है, जैसे कि Models::User::Validations models/user/validations.rb , पहले models/user/validations.rb फ़ाइल को खोजने और इसे डाउनलोड करने का प्रयास करें। , और उसके बाद ही, विफलता के मामले में, एक NameError अपवाद से NameError और फेंक दें।

निष्कर्ष

मुझे आशा है कि कोई व्यक्ति अपने लिए लेख से कुछ उपयोगी निकाल सकता है और दुनिया में यह एक डेढ़ हजार समय के लिए एक चमकदार-पठनीय कोड और मॉडल से थोड़ा कम हो जाता है।

अपडेट:
फिर निजीकरण ने देखा कि मैं कोड में गूंगा था, जो बिना किसी चिंता के, instance_eval , मैं भूल गया। कोड सही किया। मनमर्जी के लिए कर्म में कॉमरेड प्लस।