रूबी में चिंता। साथ ही टॉप-लेवल से क्लासेस भी छिपाते हैं

बहुत दूर नहीं जाने के लिए, हम तुरंत शर्तों को परिभाषित करेंगे।

• एनकैप्सुलेशन - डेटा और फ़ंक्शंस को एक ही घटक में पैक करना।
• Concealment - एक डिजाइन सिद्धांत है, जिसमें कार्यक्रम के विभिन्न हिस्सों को एक-दूसरे के आंतरिक घटकों तक पहुंच में अंतर करना शामिल है।

विकी से लिया गया। एनकैप्सुलेशन के साथ रूबी प्रोग्रामिंग भाषा में, सब कुछ ठीक लगता है। पहली नज़र में छिपने के साथ-साथ, स्थानीय चर, उदाहरण चर, विधियों के विभिन्न स्तर ( public , protected , private ) हमारे लिए उपलब्ध हैं। लेकिन कभी-कभी यह पर्याप्त नहीं हो सकता है।

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

 class User class Address < String def ==(other_object) #   end end def initialize(name:, address: nil) @name = name @address = Address.new(address) end end 

हम User अंदर Address वर्ग की घोषणा करते हैं, हम मानते हैं कि यह केवल कुछ सार पता नहीं है, लेकिन विशिष्ट तर्क के साथ एक पता जो केवल User वस्तुओं के संदर्भ में आवश्यक है। और इसके अलावा, हम नहीं चाहते कि यह Address कार्यक्रम में कहीं से भी सुलभ हो, अर्थात न केवल User अंदर इसे अलग कर देता है, बल्कि इसे अन्य सभी वस्तुओं के लिए छिपाना चाहता है। यह कैसे करना है?

आप इसे private माध्यम से आज़मा सकते हैं।

 class User private class Address < String def ==(other_object) #   end end end 

pry अंदर उदाहरण के लिए pry और निष्पादित करते हैं और प्राप्त करते हैं:

 User::Address => User::Address User::Address.new => "" 

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

NameError: private constant User::Address referenced

अब हम समस्या को और जटिल बनाते हैं। एक कैशिंग क्लास जोड़ें जो रेडिस का उपयोग करेगा।

 #shared_cache.rb require 'redis' class SharedCache end 

और ऐसा लगता है कि कुछ भी परेशानी नहीं दिखा रहा है, जब तक कि व्यू के बीच में, redis.get टेम्पलेट के अंदर, कोई व्यक्ति redis.set redis.get \ redis.set लिखना नहीं चाहता है, यहां तक ​​कि SharedCache को भी दरकिनार करता है। हम निम्नानुसार इलाज करते हैं:

 require 'redis' SharedCache.send :const_set, :Redis, Redis Object.send :remove_const, :Redis Redis NameError: uninitialized constant Redis from (pry):7:in `__pry__' 

क्या हुआ? remove_const को कॉल के माध्यम से remove_const हम Redis को ऑब्जेक्ट्स के वास्तविक टॉप-लेवल दृश्यता से हटाते हैं। लेकिन इनसे पहले, हमने SharedCache को SharedCache अंदर डाल दिया। इसके अलावा, हम SharedCache::Redis माध्यम से SharedCache::Redis तक पहुंच को प्रतिबंधित कर सकते हैं। हालांकि, इस मामले में, हम अब किसी भी तरह से Redis वर्ग तक नहीं पहुंच पाएंगे, भले ही हम इसे कहीं और उपयोग करना चाहते हों। हम आगे बढ़ते हैं और हमें कई वर्गों के अंदर require है:

 class SharedCache require_to 'redis', :Redis private_constant :Redis def storage Redis end end class SharedCache2 require_to 'redis', :Redis private_constant :Redis end 

रेडिस को कॉल करने का प्रयास:

 [1] pry(main)> SharedCache::Redis NameError: private constant SharedCache::Redis referenced from (pry):1:in `<main>' [2] pry(main)> require 'redis' => false [3] pry(main)> Redis NameError: uninitialized constant Redis from (pry):6:in `<main>' [4] pry(main)> SharedCache.new.storage => Redis [5] pry(main)> SharedCache2::Redis NameError: private constant SharedCache2::Redis referenced from (pry):1:in `<main>' 

इसका उपयोग किस लिए किया जा सकता है:

• आंतरिक उपयोगिता वर्गों को किसी अन्य वर्ग या मॉड्यूल के अंदर छिपाने के लिए।
• सर्विस क्लासेस के अंदर तर्क छिपाने के साथ एनकैप्सुलेशन - आप सर्विस ऑब्जेक्ट्स को दरकिनार करते हुए कुछ क्लासेस तक पहुँच को रोक सकते हैं।
• शीर्ष-स्तर की दृश्यता से "खतरनाक" कक्षाएं निकालें, उदाहरण के लिए, व्यू या सीरियल से डेटाबेस तक पहुंच को प्रतिबंधित करने के लिए। रेल में, आप सभी ActiveRecord कक्षाओं को "छिपा" सकते हैं और उन्हें विशिष्ट स्थानों तक चयनात्मक पहुँच प्रदान कर सकते हैं।

और require_to का एक उदाहरण कार्यान्वयन जो शीर्ष स्तर से स्थिरांक को दृश्यता के वांछित स्तर तक ले जाता है।

 class Object def const_hide sym, obj _hidden_consts.const_set sym, obj Object.send :remove_const, sym end def hidden_constants _hidden_consts.constants end def hidden_const sym _hidden_consts.const_get sym end def require_to(name, sym, to: nil) require name if Object.const_defined? sym obj = Object.const_get sym const_hide sym, obj else obj = hidden_const sym end (to || self).const_set sym, obj end private def _hidden_consts @@_hidden_consts ||= Class.new end end