रूबी में स्प्लिट स्ट्रिंग्स कैसे करें

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

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

अपने सबसे बुनियादी रूप में, स्ट्रिंग # विभाजन एक एकल तर्क लेता है: स्ट्रिंग के रूप में क्षेत्र का परिसीमन। यह सीमांकक आउटपुट से हटा दिया जाएगा और सीमांकक पर विभाजित स्ट्रिंग्स का एक सरणी वापस आ जाएगा।

इसलिए, निम्नलिखित उदाहरण में, उपयोगकर्ता इनपुट को उनके नाम को सही ढंग से मानते हुए, आपको तीन-तत्व प्राप्त करना चाहिए सरणी बंटवारे से।

#! / usr / bin / env माणिक
प्रिंट करें "आपका पूरा नाम क्या है? "
full_name = get.chomp
नाम = full_name.split ('')
"आपका पहला नाम # {name.first} है"
"आपका अंतिम नाम # {name.last}" है

यदि हम इस कार्यक्रम को चलाते हैं और नाम दर्ज करते हैं, तो हमें कुछ अपेक्षित परिणाम मिलेंगे। यह भी ध्यान दें

$ माणिक विभाजित ।rb
आपका पूरा नाम क्या है? माइकल सी। मोरिन
आपका पहला नाम माइकल है
आपका अंतिम नाम मोरिन है

तथापि, स्ट्रिंग # विभाजन जितना आप सोचते हैं उससे थोड़ा अधिक स्मार्ट है। अगर करने के लिए तर्क स्ट्रिंग # विभाजन एक स्ट्रिंग है, यह वास्तव में कि सीमांकक के रूप में उपयोग करता है, लेकिन अगर तर्क एक एकल स्थान के साथ एक स्ट्रिंग है (जैसा कि हमने इस्तेमाल किया), फिर यह संक्रमित करता है कि आप किसी भी व्हाट्सएप पर विभाजित करना चाहते हैं और आप किसी भी प्रमुख व्हाट्सएप को हटाना चाहते हैं।

इसलिए, अगर हम इसे कुछ विकृत विकृत इनपुट जैसे कि देते हैं

माइकल सी। मोरिन

(अतिरिक्त स्थानों के साथ), फिर स्ट्रिंग # विभाजन अब भी वही करेगा जो अपेक्षित है। हालाँकि, यह एकमात्र विशेष मामला है जब आप पास करते हैं तार पहले तर्क के रूप में। नियमित अभिव्यक्ति डेलिमिटर

आप पहले तर्क के रूप में एक नियमित अभिव्यक्ति भी पास कर सकते हैं। यहाँ, स्ट्रिंग # विभाजन थोड़ा और लचीला हो जाता है। हम अपने छोटे नाम को विभाजित करने वाले कोड को और भी स्मार्ट बना सकते हैं।

हम मध्य प्रारंभिक के अंत में अवधि नहीं चाहते हैं। हम जानते हैं कि यह एक मध्य प्रारंभिक है, और डेटाबेस को वहां कोई अवधि नहीं चाहिए, इसलिए हम अलग होने के दौरान इसे निकाल सकते हैं। कब स्ट्रिंग # विभाजन एक नियमित अभिव्यक्ति से मेल खाता है, यह वही सटीक कार्य करता है जैसे कि यह सिर्फ एक स्ट्रिंग सीमांकक से मेल खाता था: यह इसे आउटपुट से बाहर ले जाता है और उस बिंदु पर विभाजित करता है।

इसलिए, हम अपने उदाहरण को थोड़ा विकसित कर सकते हैं:

$ बिल्ली अलग हो गई। आरबी
#! / usr / bin / env माणिक
प्रिंट करें "आपका पूरा नाम क्या है? "
full_name = get.chomp
नाम = full_name.split (/ \?? s + /)
"आपका पहला नाम # {name.first} है"
"आपका मध्य आरंभिक नाम # {नाम [1]}" है
"आपका अंतिम नाम # {name.last}" है

माणिक वास्तव में "विशेष चर" पर बड़ा नहीं है जो आपको पर्ल जैसी भाषाओं में मिल सकता है, लेकिन स्ट्रिंग # विभाजन आप के बारे में पता होना चाहिए एक का उपयोग करता है यह डिफ़ॉल्ट रिकॉर्ड विभाजक चर है, जिसे के रूप में भी जाना जाता है $;.

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

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

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

यह स्ट्रिंग पर पुनरावृत्ति के लिए उपयोगी हो सकता है और प्री-1.9.x और प्री-1.8.7 में उपयोग किया गया था (जो एक बैकपार्ट किया गया था 1.9.x से सुविधाओं की संख्या) टूटने की चिंता किए बिना एक स्ट्रिंग में वर्णों पर पुनरावृति करने के लिए मल्टी-बाइट यूनिकोड वर्ण. हालाँकि, यदि आप वास्तव में क्या करना चाहते हैं, यह एक स्ट्रिंग पर पुनरावृति है, और आप 1.8.7 या 1.9.x का उपयोग कर रहे हैं, तो आपको संभवतः उपयोग करना चाहिए स्ट्रिंग # each_char बजाय।

#! / usr / bin / env माणिक
str = "उसने मुझे एक न्यूट में बदल दिया!"
str.split ('')। प्रत्येक do | c |
डालता है
समाप्त

उदाहरण के लिए हमारे नाम पर वापस जाएं, अगर किसी के पास उनके अंतिम नाम में जगह है तो क्या होगा? उदाहरण के लिए, डच उपनाम अक्सर "वैन" (जिसका अर्थ "" या "से") से शुरू हो सकता है।

हम केवल एक 3-तत्व चाहते हैं सरणी, इसलिए हम दूसरे तर्क का उपयोग कर सकते हैं स्ट्रिंग # विभाजन कि हमने अब तक अनदेखी की है। दूसरा तर्क एक होने की उम्मीद है Fixnum. यदि यह तर्क सकारात्मक है, तो कम से कम, कि कई तत्व सरणी में भरे जाएंगे। इसलिए हमारे मामले में, हम इस तर्क के लिए 3 पास करना चाहेंगे।

#! / usr / bin / env माणिक
प्रिंट करें "आपका पूरा नाम क्या है? "
full_name = get.chomp
नाम = full_name.split (/ \?? s + /, 3)
"आपका पहला नाम # {name.first} है"
"आपका मध्य आरंभिक नाम # {नाम [1]}" है
"आपका अंतिम नाम # {name.last}" है

यदि हम इसे फिर से चलाते हैं और इसे एक डच नाम देते हैं, तो यह अपेक्षित रूप से कार्य करेगा।

$ माणिक विभाजित ।rb
आपका पूरा नाम क्या है? विंसेंट विलेम वैन गॉग
आपका पहला नाम विन्सेन्ट है
आपका मध्य प्रारंभिक विलेम है
आपका अंतिम नाम वान गाग है

हालांकि, यदि यह तर्क नकारात्मक है (कोई नकारात्मक संख्या), तो की संख्या पर कोई सीमा नहीं होगी आउटपुट एरे में तत्व और किसी भी ट्रेलिंग सीमांकक के अंत में शून्य-लंबाई के तार के रूप में दिखाई देगा सरणी।

इस IRB स्निपेट में यह प्रदर्शित किया गया है:

: 001> "यह, है, परीक्षण," .plplit (',', -1)
=> ["यह", "है", "ए", "परीक्षण", "", "", "", ""]