ड्राई-आरबी क्या है?

कोशिश करने के लिए कुछ नए और दिलचस्प रत्न खोज रहे हैं?

फिर सूखी-आरबी . पर एक नज़र डालें , रत्नों का एक समूह जो सामान्य समस्याओं का समाधान लाता है। ड्राई-आरबी 18 से अधिक रूबी रत्नों से बना है जो एक साथ या अपने आप काम कर सकते हैं।

इनमें से कुछ रत्न शामिल हैं :

• ड्राई-इनिशियलाइज़र
• सूखी संरचना
• सूखी-सत्यापन
• ड्राई-इवेंट
• सूखा लेन-देन

इस पोस्ट में, आप इनमें से 3 रत्नों के बारे में जानेंगे ताकि आप इसका स्वाद ले सकें कि dry-rb क्या है पेशकश करनी होगी!

ड्राई-स्ट्रक्चर के साथ बेहतर स्ट्रक्चर कैसे बनाएं

रूबी स्ट्रक्चर एक प्रकार की वस्तु है जिसे आप स्ट्रक्चर क्लास से बना सकते हैं, लेकिन उनकी कुछ सीमाएँ हैं।

उदाहरण के लिए :

आप कई लापता तर्कों के साथ एक संरचना बना सकते हैं और रूबी से कोई शिकायत नहीं प्राप्त कर सकते हैं।

dry-struct के साथ मणि आप सख्त संरचना बना सकते हैं।

यहां बताया गया है :

require 'dry-struct'

module Types
  include Dry::Types.module
end

class Video < Dry::Struct
  attribute :title, Types::String
  attribute :views, Types::Views
  attribute :comments, Types::Array
end

Video.new(title: "abc", views: 10, comments: [])

अब यदि आप किसी एक विशेषता को याद करते हैं, तो आपको यह त्रुटि मिलती है:

[Video.new] :comments is missing in Hash input

सबसे उपयोगकर्ता के अनुकूल त्रुटि संदेश नहीं है, लेकिन यह काम पूरा करता है।

आप अपने स्वयं के प्रकार बना सकते हैं और उनमें बाधाएं जोड़ें:

module Types
  include Dry::Types.module

  Age = Integer.constrained(gt: 0)
end

इस "gt" का अर्थ है "इससे बड़ा"।

तो Age 0 से बड़ा पूर्णांक होना चाहिए।

क्या आपके पास डिफ़ॉल्ट मान हो सकते हैं?

हां, यहां बताया गया है :

module Types
  include Dry::Types.module

  Name = String.default('')
end

ड्राई स्ट्रक्चर बनाने के लिए एक छोटा संस्करण है, जो नियमित रूबी स्ट्रक्चर जैसा दिखता है।

उदाहरण :

Book = Dry::Struct(title: Dry::Types["string"])

Book.new(title: "Computer Science 101")

ड्राई-इवेंट के साथ ऑब्जर्वर पैटर्न लागू करना

ऑब्जर्वर डिज़ाइन पैटर्न तब होता है जब एक स्रोत कई श्रोताओं . के लिए एक अपडेट प्रकाशित करता है , यह एक समाचार अपडेट, स्टॉक अलर्ट, समूह चैट में नया संदेश आदि हो सकता है।

यह एक सामान्य पैटर्न है।

रूबी में एक अवलोकन योग्य मॉड्यूल . शामिल है जो आपको इसे लागू करने में मदद करता है।

लेकिन dry-events एक और विकल्प है।

आप इस तरह एक प्रकाशक बना सकते हैं :

require 'dry/events/publisher'

class Blog
  include Dry::Events::Publisher[:blog]

  register_event('article.published')
  register_event('article.upated')
end

अब :

कोई भी वर्ग इन घटनाओं के होने पर उन्हें प्राप्त करने के लिए खुद को पंजीकृत कर सकता है।

यहां बताया गया है :

class Reader
  def on_article_published(event)
    puts "New article published: #{event[:title]}"
  end

  def on_article_updated(event)
    puts "Article has been updated: #{event[:title]}"
  end
end

blog   = Blog.new
reader = Reader.new

blog.subscribe(reader)

आप किसी ईवेंट को publish . के साथ प्रसारित कर सकते हैं विधि:

blog.publish('article.published', title: 'How to Use The dry-events Gem')

इस रत्न के साथ एक बात मैंने देखी है कि यदि आप किसी ऐसी घटना की सदस्यता लेते हैं या प्रकाशित करते हैं जो मौजूद नहीं है यह चुपचाप विफल हो जाएगी ।

ड्राई-ऑटो_इंजेक्ट के साथ डिपेंडेंसी इंजेक्शन

निर्भरता क्या है?

एक निर्भरता एक ऐसी चीज है जिसे एक वर्ग को अन्य वस्तुओं और वर्गों की तरह काम करने की आवश्यकता होती है।

आप इन वस्तुओं को सीधे अपनी कक्षा में बना सकते हैं...

या आप निर्भरता इंजेक्शन . का उपयोग कर सकते हैं ।

निर्भरता इंजेक्शन तब होता है जब निर्भरताओं को कक्षा में "इंजेक्शन" किया जाता है। दूसरे शब्दों में, उन्हें पैरामीटर के रूप में पास किया जाता है।

उदाहरण :

require 'faraday'

class GitHubAPI
  def initialize(http_client = Faraday.new)
    @http_client = http_client
  end
end

ऐसा करने से आप निर्भरता को नियंत्रित कर सकते हैं और परीक्षण को आसान बना सकते हैं।

अब :

dry-auto_inject आपके लिए इन वस्तुओं को बनाता है। आपको केवल यह घोषित करना है कि किन निर्भरताओं की आवश्यकता है।

इस उदाहरण में Fruit Store . पर निर्भर करता है :

require 'dry/auto_inject'

class Store
  def bananas
    puts 'Have some organic bananas!'
  end
end

Import = Dry::AutoInject({ 'store' => Store.new })

class Fruit
  include Import['store']

  def eat
    store.bananas
  end
end

fruit = Fruit.new
fruit.eat

आपको यह बताना होगा कि वस्तु कैसे बनाई जाती है:

Import = Dry::AutoInject({ 'store' => Store.new })

और इसे कक्षा के लिए उपलब्ध कराएं:

include Import['store']

फिर आप एक Fruit बना सकते हैं एक अलग Store . के साथ इस तरह:

Fruit.new(store: MyStore.new)

निर्भरता इंजेक्शन का उपयोग करने के लिए आपको रत्न की आवश्यकता नहीं है, लेकिन इसे करने का एक और तरीका देखना दिलचस्प है।

सारांश

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

अब अभ्यास करने और इसे आजमाने की आपकी बारी है!

पढ़ने के लिए धन्यवाद।