रूबी में बचने वाले पात्र

इस पोस्ट में हम रूबी में बचने वाले पात्रों के बारे में बात करने जा रहे हैं। हम सीखेंगे कि पात्रों से कैसे बचें, यह कैसे काम करता है, और कुछ उपयोग के मामलों में पूरी तरह से बचने से कैसे बचें। अगर आपको लगता है कि आप \ . के बारे में सब कुछ जानते हैं , यह सब पढ़ना सुनिश्चित करें और आश्चर्यचकित हो जाएं...

आइए, स्ट्रिंग्स में बचने वाले चरित्र के साथ सीधे चलते हैं।

उद्धरण से बचना

रूबी में स्ट्रिंग्स का उपयोग करते समय, हमें कभी-कभी स्ट्रिंग के अंदर स्ट्रिंग को परिभाषित करने के लिए उपयोग किए जाने वाले उद्धरण को रखने की आवश्यकता होती है। जब हम ऐसा करते हैं, तो हम बैकस्लैश \ के साथ कोट कैरेक्टर से बच सकते हैं। प्रतीक।

# Escape quotes in double quoted strings
"Hello \"world\"!"
=> "Hello \"world\"!"
 
# Escape quotes in single quoted strings
'Hello \'world\'!'
=> "Hello 'world'!"

यहां हम देख सकते हैं कि रूबी आउटपुट के लिए डबल कोटेड स्ट्रिंग्स को डिफॉल्ट करती है और आउटपुट में केवल उन डबल कोट्स से बच जाती है।

एस्केप सीक्वेंस

उद्धरणों के अलावा, और भी प्रतीक हैं जिनसे हम स्ट्रिंग्स में बच सकते हैं। उदाहरण के लिए, एक नई पंक्ति को \n . द्वारा दर्शाया जाता है . इसे "एस्केप सीक्वेंस" कहा जाता है।

"Hello\nworld"
=> "Hello\nworld"

जो लौटाया जाता है वह वही स्ट्रिंग है जैसा हमने बनाया था, लेकिन जैसा कि आप देख सकते हैं \n हाइलाइट किया गया है, यह दर्शाता है कि यह एक एस्केप अनुक्रम है। अगर हम अब इस स्ट्रिंग को प्रिंट करेंगे तो हम देखेंगे कि शाब्दिक \n मुद्रित नहीं है, लेकिन इसके बजाय एक वास्तविक नई पंक्ति मुद्रित की जाती है।

puts "Hello\nworld"
=> Hello
world

यह सिंगल कोटेड स्ट्रिंग्स में काम नहीं करता है। \n अनुक्रम की व्याख्या एक शाब्दिक \n . के रूप में की जाती है . डबल कोटेड स्ट्रिंग्स में आपको समान परिणाम प्राप्त करने के लिए बैकस्लैश सिंबल से बचना होगा।

'\n'
=> "\\n"

इसी तरह काम करने वाले अन्य एस्केप अनुक्रमों के उदाहरण हैं:\t , \s और \b , जो क्रमशः एक टैब, एक स्थान और एक बैकस्पेस का प्रतिनिधित्व करता है।

एकल उद्धरण <स्ट्राइक>बनाम और दोहरे उद्धरण

रूबी में सिंगल और डबल कोटेड स्ट्रिंग्स के बीच का अंतर यह है कि जिस तरह से स्ट्रिंग डेफिनिशन एस्केप सीक्वेंस का प्रतिनिधित्व करती है।

• डबल . में उद्धृत तार, आप एस्केप सीक्वेंस लिख सकते हैं और रूबी उनके अनुवादित अर्थ को आउटपुट करेगा। एक \n एक नई पंक्ति बन जाती है।
• एकल . में उद्धृत तार हालांकि, बचने के अनुक्रम बच निकले हैं और उनकी शाब्दिक परिभाषा वापस कर दी गई है। एक \n एक \n रहता है ।

दोनों स्ट्रिंग प्रकारों में निश्चित रूप से उनके उपयोग के मामले हैं। संभव है कि आप एस्केप सीक्वेंस के साथ डबल कोटेड स्ट्रिंग्स का उपयोग उनके अनुवादित अर्थ, एक नई लाइन या एक टैब का उपयोग करने के लिए करेंगे।

एकल उद्धरण स्वयं बचने के क्रम से बचने के लिए उपयोगी होते हैं। उनके उपयोग को प्रदर्शित करने के लिए उपयोगी है या गलती से बचने के उन दृश्यों से बचने के लिए जिनका आपने इरादा नहीं किया था।

puts "Line 1\nLine 2"
=> Line 1
Line 2
 
puts 'Using a \n we can indicate a newline.'
=> Using a \n we can indicate a newline.

प्रक्षेप से बचना

रूबी स्ट्रिंग्स के अंदर इंटरपोलेशन का समर्थन करती है। लेकिन एक बार फिर, सभी स्ट्रिंग परिभाषाएं समान नहीं बनाई गई हैं। इंटरपोलेशन केवल डबल कोटेड स्ट्रिंग्स में काम करता है।

नीचे दिए गए कोड उदाहरण में हम देखते हैं कि इंटरपोलेशन एक डबल उद्धृत स्ट्रिंग में काम करता है, लेकिन रूबी एक उद्धृत स्ट्रिंग में इंटरपोलेशन अनुक्रम से बच निकलती है, जिससे यह बेकार हो जाती है।

name = "world"
 
"Hello #{name}"
=> "Hello world"
 
'Hello #{name}'
=> "Hello \#{name}"

यह व्यवहार लगभग हर प्रकार की स्ट्रिंग "जादू" पर लागू होता है। दोहरे उद्धरण इसका समर्थन करते हैं, एकल उद्धरण इसका समर्थन नहीं करते हैं।

स्ट्रिंग के लिए प्रतिशत अंकन

रूबी में प्रतिशत अंकन पर्ल प्रोग्रामिंग भाषा से प्रेरित कुछ है और हमें कुछ सामान्य प्रकार की परिभाषाओं के लिए कई शॉर्टहैंड देता है।

सिंगल और डबल कोटेड स्ट्रिंग्स के लिए समान व्यवहार प्रतिशत नोटेशन पर भी लागू होता है।

• %() और %Q() एक डबल उद्धृत स्ट्रिंग के समान व्यवहार करें।
• %q() एक ही उद्धृत स्ट्रिंग के समान व्यवहार करता है।

प्रतिशत संकेतन के साथ समस्या यह है कि अब आपको कोष्ठक वर्णों से बचने की आवश्यकता है () कोष्ठक संतुलित नहीं होने पर उद्धरणों के बजाय।

यही कारण है कि रूबी आपको प्रतिशत अंकन के लिए अन्य प्रतीकों का भी उपयोग करने की अनुमति देता है:%[foo] , %{foo} , %-foo- , %?foo? , आदि। यह %"foo" . का भी समर्थन करता है और %'foo' ।

यहाँ हम देखते हैं कि प्रतिशत अंकन का उपयोग करते समय रूबी हमारे लिए स्ट्रिंग से बच जाती है।

%(Hello "world"!)
=> "Hello \"world\""
 
# With unbalanced parenthesis
%(Hello world\)!)
=> "Hello world)!"
 
# With balanced parenthesis
%(Hello (world)!)
=> "Hello (world)!"

फिर से, वही नियम यहां लागू होते हैं जैसे सामान्य सिंगल और डबल कोटेड स्ट्रिंग्स के साथ। एस्केप सीक्वेंस और इंटरपोलेशन सिंगल कोटेड स्ट्रिंग्स में डिफ़ॉल्ट रूप से बच जाते हैं।

name = "world"
 
%(Hello\n "#{name}"!)
=> "Hello\n \"world\"!"
 
%q(Hello\n "#{name}"!)
=> "Hello\\n \"\#{name}\"!"
 
%Q(Hello\n "#{name}"!)
=> "Hello\n \"world\"!"

रेगुलर एक्सप्रेशन में वर्णों से बचना

एस्केपिंग कैरेक्टर रेगुलर एक्सप्रेशन में भी काम करता है। रेगुलर एक्सप्रेशन में कई वर्ण केवल उनकी शाब्दिक परिभाषा से अधिक का प्रतिनिधित्व करते हैं।

. किसी भी वर्ण के लिए वाइल्ड कार्ड है, कोष्ठक [] एक श्रेणी या चयन का प्रतिनिधित्व करते हैं, कोष्ठक () एक व्यंजक का मिलान करें, आदि। उनकी शाब्दिक परिभाषाओं का उपयोग करने के लिए हम उन्हें बैकस्लैश प्रतीक से भी बचा सकते हैं।

/Hello \[world\]/
=> /Hello \[world\]/
 
/\[world\]/ =~ "Hello [world]"
=> 6

यदि हम कोष्ठक से नहीं बचते हैं, तो यह इसके बजाय कोष्ठक के बीच किसी भी वर्ण की तलाश करेगा और वर्ण l में पहला मिलान ढूंढेगा। स्थिति 3 पर "नमस्ते" में।

/[world]/ =~ "Hello [world]"
=> 2 # zero index

फॉरवर्ड स्लैश सिंबल से बचने के लिए / , रेगुलर एक्सप्रेशन को परिभाषित करने के लिए उपयोग किया जाता है, हम अन्य प्रतिशत अंकन का उपयोग कर सकते हैं।

%r{/world/}
=> /\/world\//

%r{} का उपयोग करना हम एक नियमित अभिव्यक्ति को परिभाषित कर सकते हैं जहां हमें फॉरवर्ड स्लैश से बचना नहीं है। परिणाम में हम देख सकते हैं कि रूबी हमारे लिए फॉरवर्ड स्लैश से बच जाती है।

लाइन ब्रेक से बचना

पहले हम "न्यूलाइन" एस्केप सीक्वेंस \n . से बच गए थे रूबी में एक स्ट्रिंग में। क्या आप जानते हैं कि आप रूबी में ही लाइन ब्रेक से भी बच सकते हैं?

उदाहरण के लिए, हमारे पास मेथड कॉल के लिए बहुत लंबी लाइन है और यह हमारी कोड स्टाइल गाइड की अधिकतम लाइन लंबाई को तोड़ देती है।

ruby_method_with_many_arguments "Hello world", split: " ", join: "\n"

प्रत्येक अलग-अलग लाइन को छोटा करने के लिए हम तर्कों को अलग-अलग पंक्तियों में रख सकते हैं। यह तब तक काम करता है जब तक पिछली पंक्ति अल्पविराम से समाप्त होती है , , ऑपरेटरों को प्लस चिह्न पसंद है + , या कोष्ठक में लिपटे एक विधि कॉल का हिस्सा है () ।

ruby_method_with_many_arguments "Hello world",
  split: " ",
  join: "\n"
 
ruby_method_with_many_arguments(
  "Hello world",
  split: " ",
  join: "\n"
)

यदि इसके बजाय हम सभी तर्कों को एक ही इंडेंटेशन स्तर पर कोष्ठक में लपेटे बिना संरेखित करना चाहते हैं () हम बैकस्लैश का उपयोग कर सकते हैं \ लाइन ब्रेक से बचने के लिए।

ruby_method_with_many_arguments \
  my_string,
  split: " ",
  join: "\n"

हम यहां जो करते हैं वह वास्तव में रूबी को नई लाइन से बचने के लिए नहीं कह रहा है, लेकिन यह कि कथन अगली पंक्ति पर जारी रहेगा।

स्ट्रिंग परिभाषाओं में एस्केपिंग लाइन ब्रेक

लाइन एंडिंग से बचना स्ट्रिंग परिभाषाओं जैसी चीजों के लिए भी काम करता है। आम तौर पर यदि हमारे पास एक बहु-पंक्ति स्ट्रिंग है तो हम प्लस चिह्न + . का उपयोग कर सकते हैं तारों को दो पंक्तियों में संयोजित करने के लिए।

"foo" +
  "bar"
=> "foobar"

यह दो पंक्तियों पर दो तार बनाता है और फिर एक के रूप में संयोजित होता है। तो यह वास्तव में तीन स्ट्रिंग ऑब्जेक्ट बनाता है।

प्लस चिह्न का उपयोग करने के बजाय, हम फिर से बैकस्लैश के साथ लाइन ब्रेक से बच सकते हैं।

"foo" \
  "bar"
=> "foobar"

नतीजा वही है, या है?

पहले उदाहरण में हम वास्तव में दो नए तार जोड़ रहे हैं, जबकि दूसरे उदाहरण में रूबी केवल एक बनाएगी। रूबी दुभाषिया बैकस्लैश देखेगा \ स्ट्रिंग परिभाषा की निरंतरता के रूप में और केवल दो पंक्तियों के आधार पर एक स्ट्रिंग बनाएं। तो यह आपके ऐप के मेमोरी उपयोग के लिए और भी बेहतर है।

निष्कर्ष

रूबी और कई अन्य प्रोग्रामिंग भाषाओं में पात्रों से बचना काफी भ्रमित करने वाला हो सकता है। एक उद्धृत स्ट्रिंग के अंदर उपयोग किए जाने की तुलना में अचानक वर्णों के कुछ संयोजन दोहरे उद्धृत स्ट्रिंग के अंदर एक अलग अर्थ प्राप्त करते हैं।

उम्मीद है कि इस छोटी सी मार्गदर्शिका ने आपको रूबी में पात्रों और अनुक्रमों से ठीक से बचने के तरीके को समझने में मदद की है। डबल और सिंगल कोटेड स्ट्रिंग के बीच का अंतर यहां महत्वपूर्ण है।

एस्केप सीक्वेंस और इंटरपोलेशन का स्ट्रिंग "मैजिक" वास्तव में केवल डबल कोटेड स्ट्रिंग्स में काम करता है, लेकिन सिंगल कोटेड स्ट्रिंग्स में नहीं।

रूबी में ही कोड से बचने के अन्य तरीके भी हैं। प्रतिशत अंकन हमें स्ट्रिंग्स और रेगुलर एक्सप्रेशन में हर समय कुछ वर्णों से बचने में मदद करता है।

लेकिन बैकस्लैश मल्टी-लाइन स्ट्रिंग्स लिखने और अगली लाइन पर रूबी कोड की एक लाइन जारी रखने के लिए भी बहुत उपयोगी है। कुछ ऐसा जो मैं अपने कोड को साफ और पठनीय रखने के लिए बहुत उपयोग करता हूं।

यदि आप अधिक जानना चाहते हैं, या रूबी में पात्रों से बचने के बारे में कोई विशिष्ट प्रश्न पूछना चाहते हैं, तो हमें @AppSignal पर बताएं।

मजेदार साइड-नोट:इस पोस्ट के लिए, जो मार्कडाउन में लिखा गया है, मुझे बैकस्लैश सिंबल का काफी इस्तेमाल करना पड़ा। रूबी की तरह ही, मार्कडाउन कुछ पात्रों से बचने की अनुमति देता है। आम तौर पर मार्कडाउन में आप कोड ब्लॉक में बैकस्लैश को वास्तव में लपेट नहीं सकते क्योंकि यह कोड ब्लॉक से ही बच जाता है। इसके बजाय मैं इसके बजाय एक स्थान से बच गया था।

`\` # Doesn't work
`\ ` # Works :)