Ruby Academy · पाठ

सामान्य Bottlenecks

Ruby code को तेज़ करें

पाठ 4, कुल 4 में से13 चरण

सामान्य Bottlenecks, CoddyKit पर Ruby Academy का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह Ruby Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Ruby Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

प्रदर्शन-अड़चनों की पहचान

Ruby में होने वाला अधिकांश धीमापन कुछ बार-बार दिखाई देने वाले तरीकों से आता है। उन्हें पहचानने पर आप कोड को जल्दी ठीक कर सकते हैं।

काम के लिए गलत डेटा संरचना
ऐसा दोहराया गया काम जिसे कैश किया जा सकता है
N+1 अनुरोध और नेस्टेड लूप

इस पाठ में सबसे आम समस्याओं को शामिल किया गया है।

puts 'Speeding up Ruby starts with knowing the usual suspects'

Array#include? बनाम Set

Array#include? से सदस्यता जाँचना O(n) होता है। Set या हैश से O(1) समय में खोज की जा सकती है।

बार-बार सदस्यता जाँचने के लिए एक Set पहले ही बनाएँ
बड़े संग्रहों पर गति में बहुत बड़ा सुधार मिलता है

require 'set'

allowed = Set.new(['a', 'b', 'c'])
puts allowed.include?('b')
puts allowed.include?('z')

नेस्टेड लूप (O(n का वर्ग))

तत्वों की हर जोड़ी की तुलना करना वर्गात्मक होता है और आकार बढ़ने पर बहुत धीमा हो जाता है।

भीतरी लूप की जगह हैश से खोज करें
O(n का वर्ग) को O(n) में बदल देता है

a = [1, 2, 3, 4]
b = [3, 4, 5]
set_b = b.to_set rescue require('set') || b.to_set
common = a.select { |x| set_b.include?(x) }
puts common.inspect

N+1 पैटर्न

लूप के भीतर संबंधित डेटा प्राप्त करने से N+1 क्रियाएँ करनी पड़ती हैं।

सूची के लिए 1 अनुरोध, फिर हर आइटम के लिए 1
इसके बजाय एक ही समूहित अनुरोध से सभी खोजें एक साथ करें

# Bad: lookup inside loop
orders = [1, 2, 3]
prices = { 1 => 10, 2 => 20, 3 => 30 }
# Good: one preloaded hash, O(1) per item
total = orders.sum { |id| prices[id] }
puts total

मेमोआइज़ेशन

उसी महँगे मान की फिर से गणना करने में समय व्यर्थ होता है। उसे ||= से मेमोआइज़ करें।

पहली गणना के बाद परिणाम को कैश करें
इसके बाद हर बार परिणाम तुरंत मिल जाता है

class Report
  def total
    @total ||= begin
      puts 'computing...'
      (1..1000).sum
    end
  end
end

r = Report.new
puts r.total
puts r.total

सही विधि चुनना

कुछ Enumerable विधियाँ कई विधियों की श्रृंखला से कहीं तेज़ होती हैं।

sum, inject(:+) से बेहतर है
any? तुरंत रुक जाता है, जबकि select.empty? ऐसा नहीं करता
find पहला मिलान मिलते ही रुक जाता है

nums = (1..1_000_000)
puts nums.any? { |n| n > 5 }
puts nums.find { |n| n > 5 }

बार-बार क्रमबद्ध करने से बचना

लूप के भीतर या बार-बार क्रमबद्ध करना महँगा होता है। एक बार क्रमबद्ध करके उसका पुनः उपयोग करें।

क्रमबद्ध करने की जटिलता O(n log n) होती है
यदि डेटा स्थिर है, तो क्रमबद्ध परिणाम को कैश करें

data = [5, 2, 8, 1, 9]
sorted = data.sort
puts sorted.first
puts sorted.last

हैश द्वारा समूह बनाना

group_by और tally बार-बार स्कैन करने के बजाय एक ही चरण में डेटा का संग्रह और समूह बनाते हैं।

tally घटनाओं की गिनती कुशलता से करता है
हाथ से गिनती करने वाले लूप की ज़रूरत नहीं पड़ती

words = ['a', 'b', 'a', 'c', 'b', 'a']
puts words.tally.inspect

स्ट्रिंग बनाने की लागत

संग्रहों के लिए बार-बार जोड़ने की तुलना में join से जोड़ना तेज़ होता है।

एक ऐरे बनाएँ, फिर एक ही बार join करें
बीच में बनने वाली कई स्ट्रिंग से बचाता है

parts = (1..5).map { |i| "item#{i}" }
puts parts.join(', ')

रेगुलर एक्सप्रेशन का संकलन

तेज़ी से चलने वाले लूप के भीतर रेगुलर एक्सप्रेशन लिटरल लिखने पर उसका संकलन परोक्ष रूप से बार-बार होता है। उसे किसी स्थिरांक में लूप के बाहर रखें।

एक बार संकलित करें और कई बार मिलान करें
जब केवल बूलियन परिणाम चाहिए, तब match? का उपयोग करें

EMAIL = /\A[^@\s]+@[^@\s]+\z/

inputs = ['a@b.com', 'nope', 'x@y.org']
valid = inputs.select { |s| EMAIL.match?(s) }
puts valid.inspect

काम को आवश्यकता तक टालना

जिसका शायद कभी उपयोग न हो, उसकी गणना न करें। लेज़ी मूल्यांकन या शर्त-जाँच से इसे टालें।

जहाँ संभव हो, तुरंत लौटें
भारी मानों की गणना केवल आवश्यकता होने पर करें

def describe(items)
  return 'empty' if items.empty?
  "#{items.size} items, first is #{items.first}"
end

puts describe([])
puts describe([10, 20])

त्वरित जाँच

प्रदर्शन-अड़चनों से जुड़ी अपनी समझ का परीक्षण करें।

इंटरैक्टिव पाठ में इसका उत्तर दें

सारांश

आपने सामान्य प्रदर्शन-अड़चनों को ठीक करना सीखा:

include? के बजाय तेज़ सदस्यता जाँच के लिए Set या हैश का उपयोग करें
पहले से लोड किए गए हैश से नेस्टेड लूप और N+1 पैटर्न हटाएँ
||= से महँगी गणनाओं को मेमोआइज़ करें
कुशल विधियाँ चुनें (sum, any?, tally) और रेगुलर एक्सप्रेशन को लूप के बाहर रखें
जिस काम की शायद ज़रूरत न पड़े, उसे टालें या छोड़ दें

लाभ की पुष्टि करने के लिए हमेशा पहले और बाद में माप लें।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Ruby सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 29
पाठ: 109

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “सामान्य Bottlenecks” पाठ निःशुल्क है?

हाँ — Ruby Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “सामान्य Bottlenecks” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। Ruby Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“सामान्य Bottlenecks” में मैं क्या सीखूँगा?

Ruby code को तेज़ करें आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Ruby Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Ruby Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Ruby Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।

“सामान्य Bottlenecks” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Ruby Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Ruby Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← Ruby Academy पर वापस जाएँ