रूबी 2.7 . में नई सुविधाएँ, तरीके और सुधार

रूबी कभी भी सुधार करना बंद नहीं करती!

संस्करण 2.7 यहां नई सुविधाओं, विधियों और प्रदर्शन सुधारों के साथ है। इसे 25 दिसंबर, 2019 को रिलीज़ किया गया था।

अब, Matz के अनुसार…

यह अंतिम 2.x संस्करण रिलीज़ है। क्योंकि अगले साल हमें रूबी 3.0 मिल रही है!

लेकिन इससे पहले कि हम वहां पहुंचें…

आइए 2.7 में कुछ बदलावों और नई सुविधाओं पर एक नज़र डालें, ताकि आप संस्करण अपडेट के लिए तैयार हो सकें।

सामग्री

• 1 गणनीय#मिली
• ब्लॉक के लिए 2 क्रमांकित पैरामीटर [प्रायोगिक]
• 3 ऐरे#चौराहे
• 4 संख्यात्मक#filter_map
• 5 एन्यूमरेटर#उत्पाद
• 6 आईआरबी को एक नया चेहरा मिलता है?
• 7 रूबी पैटर्न मिलान [प्रायोगिक]
• 8 अन्य परिवर्तन
• 9 सारांश
  • 9.1 संबंधित

एन्यूमरेबल#टैली

यह एक नई रूबी विधि है जो एक सरणी में सभी तत्वों की गणना करती है और उनकी गणना के साथ हैश लौटाती है।

आप इसे स्वयं कर सकते हैं, लेकिन यह tally विधि आपको काम बचाती है।

यहां एक उदाहरण दिया गया है :

%w(a a a b b c).tally

जिसका परिणाम होता है :

{"a"=>3, "b"=>2, "c"=>1}

मुझे यह पसंद है!

ब्लॉक के लिए क्रमांकित पैरामीटर [प्रायोगिक]

एक दिलचस्प नई सुविधा, जिसे मैं कुछ समय से चाहता था, ब्लॉक पैरामीटर के लिए एक डिफ़ॉल्ट नाम है।

यहां एक पैरामीटर के साथ एक नियमित अवरोध है :

[1,2,3].each { |n| puts n }

यह |n| वह पैरामीटर है, जिसका उपयोग करने के लिए आपको उसे परिभाषित करना होगा।

लेकिन क्या होगा यदि हमारे पास एक डिफ़ॉल्ट नाम होता?

खैर, यह उन अच्छाइयों में से एक है जो रूबी 2.7 अपने साथ लाती है, हालांकि एक प्रयोगात्मक विशेषता के रूप में , यह हमें बहुत सी टाइपिंग से बचा सकता है।

यह कैसा दिखता है :

[1,2,3].each { puts _1 }

जहां _1 पहले पैरामीटर को संदर्भित करता है, आप _2 use का उपयोग कर सकते हैं यदि आपके पास दूसरा है, और हाँ, _3 तीसरे पैरामीटर के लिए, आदि।

बहुत बढ़िया!

अब, थोड़ा सा सामान्य ज्ञान।

इस सुविधा को पहले @1 . जैसा दिखने के लिए प्रस्तावित किया गया था , लेकिन यह एक आवृत्ति चर की तरह बहुत अधिक दिखता है, इसलिए कुछ चर्चा के बाद, इसे _1 का उपयोग करने पर तय किया गया था इसके बजाय।

सरणी#चौराहे

यह एक नई विधि है, लेकिन नई कार्यक्षमता नहीं है।

दरअसल…

यह एक उपनाम की तरह है!

रूबी 2.6 ने ऐरे union की शुरुआत की &difference विधियों, Array#| . के अधिक संक्षिप्त समकक्षों से मिलान करने के लिए , और Array#- ।

लेकिन लापता ऑपरेशन था intersection , जिसका लघु संस्करण याद रखना एक और कठिन है।

Array#& method ।

अब :

ये तरीके क्या करते हैं और कैसे काम करते हैं?

उदाहरण :

[1, 2, 3].intersection([2, 3, 4])
# [2, 3]

[1, 2, 3] & [2, 3, 4]
# [2, 3]

खैर…

नाम तरह का इसे दूर देता है, intersection दो सरणियों के बीच प्रतिच्छेदन पाता है। दूसरे शब्दों में, यह पता लगाता है कि कौन से तत्व समान हैं।

मैं हमेशा भूल जाता हूं कि इन 3 तरीकों में से कौन सा तरीका क्या करता है!

लेकिन इन नए तरीकों के साथ, इसे याद रखना बहुत आसान है क्योंकि उनके नाम का कुछ मतलब होता है ।

अच्छा कोड लिखने का यह एक अच्छा सबक है, बीटीडब्ल्यू।

गणना करने योग्य#filter_map

यह filter_map विधि select को संयोजित करने का एक प्रयास है और map एक में तरीके।

क्यों?

क्योंकि पहले किसी सूची को फ़िल्टर करना, फिर शेष तत्वों को मैप करना एक सामान्य ऑपरेशन है।

आप इसे दो तरीकों से कर सकते हैं :

(1..8).select(&:even?).map { |n| n ** 2 }

# OR

(1..8).map { |n| n ** 2 if n.even? }.compact

मैंने दोनों का उपयोग किया है, लेकिन मैं पहले की ओर झुकता हूं क्योंकि इरादा अधिक स्पष्ट है।

अब :

रूबी 2.7 में, यह filter_map विधि इसे एक पास में करती है।

इसे पसंद करें :

(1..8).filter_map { |n| n ** 2 if n.even? }
# [4, 16, 36, 64]

मैं ब्लॉक के अंदर if स्टेटमेंट होने का सबसे बड़ा प्रशंसक नहीं हूं, लेकिन कभी-कभी काम पूरा करने के लिए उनकी आवश्यकता होती है।

इसके अलावा, आपको कुछ पता होना चाहिए।

filter_map ऑपरेशन map + compact की तरह व्यवहार नहीं करता है , क्योंकि यह false . को हटाता है ऑब्जेक्ट्स, और compact नहीं।

ध्यान में रखना एक अच्छी बात है!

गणक#उत्पाद

यहां एक और नई विधि है जो आपको दिलचस्प लग सकती है, लेकिन इसके लिए कुछ रचनात्मकता की आवश्यकता हो सकती है इसका अधिकतम लाभ उठाने के लिए।

यह है Enumerator#produce विधि।

यह क्या करता है?

सुविधा प्रस्ताव के अनुसार :

"यह विधि एक अनंत अनुक्रम उत्पन्न करती है जहां प्रत्येक अगले तत्व की गणना पिछले तत्व पर ब्लॉक लागू करके की जाती है।"

हां।

कभी न खत्म होने वाले क्रम बनाने का दूसरा तरीका!

यहां एक उदाहरण दिया गया है :

Enumerator.produce(1, &:next).take(5)
# [1, 2, 3, 4, 5]

इस उदाहरण में, इससे कोई फर्क नहीं पड़ता कि आप take(10) करते हैं या take(10_000) , आपको इससे असीमित संख्या में मान मिलेंगे।

बीटीडब्ल्यू, 1 प्रारंभिक मान है।

और &:next उस मान पर produce . करने की विधि है अनुक्रम में अगला तत्व।

IRB को एक नया चेहरा मिलता है?

हाल ही में, IRB को कुछ प्यार और ध्यान मिल रहा है, और Ruby 2.7 इसे और बढ़ा रहा है।

हमें मिल रहा है :

• बहु-पंक्ति संपादन
• सिंटैक्स हाइलाइटिंग
• अंतर्निहित आरडीओसी एकीकरण
• कमांड इतिहास डिफ़ॉल्ट रूप से सक्षम है
• डिफ़ॉल्ट रूप से स्वतः पूर्णता सक्षम है

वास्तव में :

यह इतना बड़ा बदलाव है कि जब आप रूबी 2.7 के साथ आईआरबी शुरू करते हैं तो आपको एक चेतावनी मिलती है।

यदि आप irb के पुराने संस्करण का उपयोग जारी रखना चाहते हैं, तो भी आप irb --legacy के साथ कर सकते हैं आज्ञा। इस नए IRB के साथ मेरा मुख्य मुद्दा लाइन एडिटिंग है, लीगेसी IRB में (या Pry में) मैं ALT पकड़ सकता हूं और तेजी से आगे बढ़ने के लिए बायां तीर दबा सकता हूं, लेकिन यह नए IRB में काम नहीं करता है।

इसे आज़माएं और देखें कि यह आपके लिए कैसे काम करता है।

रूबी पैटर्न मिलान [प्रायोगिक]

अक्सर अनुरोध की जाने वाली विशेषता जो 2.7 में आ रही है, वह है पैटर्न मिलान।

इसे प्रयोगात्मक के रूप में चिह्नित किया गया है।

लेकिन पैटर्न मिलान क्या है और इससे आपको क्या लाभ होता है?

ठीक है, अगर मैं इसे सही ढंग से समझता हूं, तो पैटर्न मिलान नियमित अभिव्यक्तियों की तरह है, लेकिन डेटा संरचनाओं (ऐरे/हैश) के लिए।

यहां एक उदाहरण दिया गया है :

[1,2,3] in [a,b,c] # true
[1,2,3] in [a]     # false

यदि कोई मेल है, तो ये चर नाम (जैसे a ) स्थानीय चर बनें जिन्हें आप एक्सेस कर सकते हैं।

हैश के साथ उदाहरण :

{ a: 1, b: 2, c: [] } in { a: a, b: b, c: [] }
# true

p a
# 1

यह in . का उपयोग करता है कीवर्ड।

यह नया नहीं है, लेकिन असामान्य है क्योंकि रूबी 2.7 से पहले in केवल for . के भाग के रूप में उपयोग किया गया था लूप (रूबी में अत्यधिक हतोत्साहित), इसलिए हमें इस कीवर्ड का पुन:उपयोग किसी उपयोगी चीज़ के लिए करना है।

और भी बेहतर …

इससे कोई फर्क नहीं पड़ता कि आप किस चर का उपयोग करते हैं, a,b,c यहाँ काम करता है, लेकिन f,g,h भी काम करता है।

यह सब पैटर्न के बारे में है!

अन्य परिवर्तन

ध्यान देने योग्य कुछ अतिरिक्त परिवर्तन।

• नया संघनन GC स्मृति विखंडन में सुधार करता है
• विधि तर्क **nil अब घोषणा करता है कि एक विधि में कोई कीवर्ड नहीं है
• विधि तर्क ... एक तर्क अग्रेषण तंत्र जोड़ता है (कोष्ठक आवश्यक है, जैसे make_salad(...) )
• फाइबर सुधार। फाइबर वस्तुओं का एक नया पूल (जिसमें से नए फाइबर आवंटित किए जाते हैं) फाइबर को अधिक कुशल बनाता है
• थ्रेड सुधार। थ्रेड बनाने का एक बेहतर, अधिक अनुकूलित तरीका मल्टी-थ्रेडिंग को तेज़ बनाता है

आप इनके बारे में क्या सोचते हैं?

2.7 के लिए समाचार फ़ाइल में फाइबर और थ्रेड निर्माण दोनों के लिए 10x प्रदर्शन सुधार का उल्लेख है, मैंने स्वयं इसका परीक्षण नहीं किया है, लेकिन यदि आप मुझे अपने परिणामों के बारे में बताते हैं।

सारांश

अब आप रूबी प्रोग्रामिंग भाषा में नवीनतम परिवर्तनों के साथ अद्यतित हैं! आपने IRB परिवर्तनों, नई विधियों और कुछ प्रयोगात्मक सुविधाओं जैसे पैटर्न मिलान के बारे में सीखा।

खबर फैलाने के लिए कृपया इस लेख को शेयर करें!

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