Ruby on Rails 5.2 - AbstractController::Caching::Fragments

मॉड्यूल AbstractController :: कैशिंग :: टुकड़े




ruby

मॉड्यूल AbstractController :: कैशिंग :: टुकड़े

फ्रैगमेंट कैशिंग का उपयोग विभिन्न ब्लॉकों को संपूर्ण कार्रवाई के रूप में कैशिंग के बिना विचारों के भीतर करने के लिए किया जाता है। यह तब उपयोगी होता है जब किसी कार्य के कुछ तत्व बार-बार बदलते हैं या जटिल स्थिति पर निर्भर होते हैं, जबकि अन्य भाग शायद ही कभी बदलते हैं या कई दलों के बीच साझा किए जा सकते हैं। कैशिंग एक्शन व्यू में उपलब्ध cache हेल्पर का उपयोग करके किया जाता है। अधिक जानकारी के लिए देखें ActionView::Helpers::CacheHelper

हालांकि यह दृढ़ता से अनुशंसा की जाती है कि आप कुंजी-आधारित कैश समाप्ति का उपयोग करें (अधिक जानकारी के लिए CacheHelper में लिंक देखें), यह कैश को मैन्युअल रूप से समाप्त करने के लिए भी संभव है। उदाहरण के लिए:

expire_fragment('name_of_cache')

सार्वजनिक प्रवृत्ति के तरीके

joint_fragment_cache_key (कुंजी) स्रोत दिखाएं
# File actionpack/lib/abstract_controller/caching/fragments.rb, line 88
def combined_fragment_cache_key(key)
  head = self.class.fragment_cache_keys.map { |k| instance_exec(&k) }
  tail = key.is_a?(Hash) ? url_for(key).split("://").last : key
  [ :views, (ENV["RAILS_CACHE_ID"] || ENV["RAILS_APP_VERSION"]), *head, *tail ].compact
end

दी गई एक कुंजी (जैसा कि expire_fragment में वर्णित है), एक कुंजी सरणी को पढ़ने, लिखने, या कैश्ड टुकड़े को समाप्त करने के लिए उपयुक्त है। सभी कुंजी के साथ शुरू होता है :views , उसके बाद ENV या ENV यदि सेट किया जाता है, उसके बाद निर्दिष्ट नियंत्रक मान के साथ समाप्त होने वाले किसी भी नियंत्रक-वाइड कुंजी उपसर्ग मानों के बाद।

expire_fragment (कुंजी, विकल्प = शून्य) स्रोत दिखाएं
# File actionpack/lib/abstract_controller/caching/fragments.rb, line 148
def expire_fragment(key, options = nil)
  return unless cache_configured?
  key = combined_fragment_cache_key(key) unless key.is_a?(Regexp)

  instrument_fragment_cache :expire_fragment, key do
    if key.is_a?(Regexp)
      cache_store.delete_matched(key, options)
    else
      cache_store.delete(key, options)
    end
  end
end

कैश से अंश निकालता है।

key तीन रूपों में से एक ले सकती है:

  • String - यह आम तौर पर पथ का रूप लेगा, जैसे pages/45/notes

  • Hash - url_for लिए एक अंतर्निहित कॉल के रूप में माना जाता है, जैसे { controller: 'pages', action: 'notes', id: 45}

  • Regexp - मेल खाने वाले किसी भी टुकड़े को हटा देगा, इसलिए %r{pages/\d*/notes} सभी नोटों को हटा सकते हैं। सुनिश्चित करें कि आप रेगेक्स ( ^ या $ ) में एंकर का उपयोग नहीं करते हैं क्योंकि वास्तविक फ़ाइल नाम मिलान की तरह ./cache/filename/path.cache । / ./cache/filename/path.cache filename/ ./cache/filename/path.cache । नोट: Regexp समाप्ति केवल उन कैश पर समर्थित है जो सभी कुंजियों पर (मेमकेच्ड के विपरीत) पुनरावृति कर सकते हैं।

options कैश स्टोर की delete विधि (या delete_matched के लिए delete_matched) के माध्यम से पारित किया जाता है।

fragment_cache_key (कुंजी) स्रोत दिखाएं
# File actionpack/lib/abstract_controller/caching/fragments.rb, line 69
      def fragment_cache_key(key)
        ActiveSupport::Deprecation.warn(<<-MSG.squish)
          Calling fragment_cache_key directly is deprecated and will be removed in Rails 6.0.
          All fragment accessors now use the combined_fragment_cache_key method that retains the key as an array,
          such that the caching stores can interrogate the parts for cache versions used in
          recyclable cache keys.
        MSG

        head = self.class.fragment_cache_keys.map { |k| instance_exec(&k) }
        tail = key.is_a?(Hash) ? url_for(key).split("://").last : key
        ActiveSupport::Cache.expand_cache_key([*head, *tail], :views)
      end

एक कुंजी दी (जैसा कि expire_fragment में वर्णित है), एक कुंजी को पढ़ने, लिखने या कैश्ड टुकड़े को समाप्त करने में उपयोग के लिए उपयुक्त देता है। सभी कुंजी views/ साथ शुरू होती views/ , उसके बाद किसी भी नियंत्रक-वाइड कुंजी उपसर्ग मान, निर्दिष्ट key मान के साथ समाप्त होता है। ActiveSupport::Cache.expand_cache_key का उपयोग करके कुंजी का विस्तार किया गया है।

fragment_exist? (कुंजी, विकल्प = शून्य) स्रोत दिखाएं
# File actionpack/lib/abstract_controller/caching/fragments.rb, line 121
def fragment_exist?(key, options = nil)
  return unless cache_configured?
  key = combined_fragment_cache_key(key)

  instrument_fragment_cache :exist_fragment?, key do
    cache_store.exist?(key, options)
  end
end

जांचें कि क्या key द्वारा expire_fragment स्थान से एक कैश्ड टुकड़ा मौजूद है (स्वीकार्य स्वरूपों के लिए expire_fragment देखें)।

read_fragment (कुंजी, विकल्प = शून्य) स्रोत दिखाएं
# File actionpack/lib/abstract_controller/caching/fragments.rb, line 109
def read_fragment(key, options = nil)
  return unless cache_configured?

  key = combined_fragment_cache_key(key)
  instrument_fragment_cache :read_fragment, key do
    result = cache_store.read(key, options)
    result.respond_to?(:html_safe) ? result.html_safe : result
  end
end

key द्वारा हस्ताक्षरित स्थान से एक कैश्ड टुकड़ा पढ़ता है (स्वीकार्य प्रारूपों के लिए expire_fragment देखें)।

write_fragment (कुंजी, सामग्री, विकल्प = शून्य) स्रोत दिखाएं
# File actionpack/lib/abstract_controller/caching/fragments.rb, line 96
def write_fragment(key, content, options = nil)
  return content unless cache_configured?

  key = combined_fragment_cache_key(key)
  instrument_fragment_cache :write_fragment, key do
    content = content.to_str
    cache_store.write(key, content, options)
  end
  content
end

key द्वारा expire_fragment गए स्थान पर content लिखता content (स्वीकार्य स्वरूपों के लिए expire_fragment देखें)।