मॉड्यूल के भीतर कक्षा को घोषित करना

Question

कार्य कोड का सर्वेक्षण (सर्वेक्षक नामक मॉड्यूल में, कम नहीं), इसे समझने की कोशिश कर रहा है। मैं इस खंड में भाग गया जिसमें एक मॉड्यूल के भीतर एक कक्षा शामिल है। क्या यह मॉड्यूल को शामिल करने जैसा ही है? यदि नहीं, तो इस तरह से ऐसा करने का क्या फायदा है? धन्यवाद।

module Surveyor 
    class Common 
    RAND_CHARS = [('a'..'z'), ('A'..'Z'), (0..9)].map{|r| r.to_a}.flatten.join 
    OPERATORS = %w(== != < > <= >= =~) 

    class << self 
     def make_tiny_code(len = 10) 
     if RUBY_VERSION < "1.8.7" 
      (1..len).to_a.map{|i| RAND_CHARS[rand(RAND_CHARS.size), 1] }.join 
     else 
      len.times.map{|i| RAND_CHARS[rand(RAND_CHARS.size), 1] }.join 
     end 
     end 

     def to_normalized_string(text) 
     words_to_omit = %w(a be but has have in is it of on or the to when) 
     col_text = text.to_s.gsub(/(<[^>]*>)|\n|\t/su, ' ') # Remove html tags 
     col_text.downcase!       # Remove capitalization 
     col_text.gsub!(/\"|\'/u, '')     # Remove potential problem characters 
     col_text.gsub!(/\(.*?\)/u,'')     # Remove text inside parens 
     col_text.gsub!(/\W/u, ' ')      # Remove all other non-word characters  
     cols = (col_text.split(' ') - words_to_omit) 
     (cols.size > 5 ? cols[-5..-1] : cols).join("_") 
     end 

     def equal_json_excluding_wildcards(a,b) 
     return false if a.nil? or b.nil? 
     a = a.is_a?(String) ? JSON.load(a) : JSON.load(a.to_json) 
     b = b.is_a?(String) ? JSON.load(b) : JSON.load(b.to_json) 
     deep_compare_excluding_wildcards(a,b) 
     end 
     def deep_compare_excluding_wildcards(a,b) 
     return false if a.class != b.class 
     if a.is_a?(Hash) 
      return false if a.size != b.size 
      a.each do |k,v| 
      return false if deep_compare_excluding_wildcards(v,b[k]) == false 
      end 
     elsif a.is_a?(Array) 
      return false if a.size != b.size 
      a.each_with_index{|e,i| return false if deep_compare_excluding_wildcards(e,b[i]) == false } 
     else 
      return (a == "*") || (b == "*") || (a == b) 
     end 
     true 
     end 

     alias :normalize :to_normalized_string 

     def generate_api_id 
     UUIDTools::UUID.random_create.to_s 
     end 
    end 
    end 
end 

Answer 1

यह इस तरह से कर रही है का लाभ क्या है: (बोनस अंक क्यों हम वर्ग के लिए स्वयं जोड़कर कर रहे हैं, जो पहले से ही निहित नहीं है?)?

यह namespace के रूप में कार्य करता है, इसलिए उसी नाम वाले वर्ग संघर्ष नहीं करते हैं (इसलिए इसमें मिश्रण के साथ कुछ भी नहीं है)। यह मानक है।

हम कक्षा में स्वयं को क्यों जोड़ रहे हैं, क्या यह पहले से ही निहित नहीं है?

यह defining class-methods (अन्य def self.method_name) के तरीकों में से एक है।

Answer 2

क्या यह मॉड्यूल समेत समान है?

नहीं। जब आप module Foo; end और फिर

class Bar 
    include Foo 
end 

आप एक वर्ग Bar कि मॉड्यूल Foo के सभी तरीके शामिल हैं के साथ खत्म करते हैं। लेकिन हम

module Foo 
    class Bar 
    end 
end 

करते हैं जब हम एक वर्ग Foo::Bar कि Foo में तरीकों में से कोई भी शामिल है के साथ खत्म हो कि Bar

में नहीं हैं क्या यह इस तरह से कर रही है का लाभ है?

यह आवश्यक है, तो यह आपके कोड को व्यवस्थित करने की अनुमति देता है।

हम कक्षा में स्वयं को क्यों जोड़ रहे हैं, क्या यह पहले से ही निहित नहीं है?

नहीं, यह पहले से ही "निहित" नहीं है। ऐसा करना self. जैसे def self.mymethod; end के साथ उस ब्लॉक में प्रत्येक विधि को परिभाषित करने के बराबर है। class << self idiom in Ruby देखें।