रूबी स्ट्रिंग से अंतिम एन अक्षर निकालना

Question

nएक स्ट्रिंग से अंतिम वर्ण प्राप्त करने के लिए , मैंने माना कि आप उपयोग कर सकते हैं

ending = string[-n..-1]

लेकिन अगर स्ट्रिंग nलंबे अक्षरों से कम है , तो आप प्राप्त करते हैं nil।

क्या वर्कअराउंड उपलब्ध हैं?

पृष्ठभूमि : तार सादे ASCII हैं, और मेरे पास माणिक 1.9.1 तक पहुंच है, और मैं प्लेन ओल्ड रूबी ऑब्जेक्ट्स (कोई वेब फ्रेमवर्क) का उपयोग नहीं कर रहा हूं।

Answer 1

यहां आपके पास एक लाइनर है, आप स्ट्रिंग के आकार से अधिक संख्या रख सकते हैं:

"123".split(//).last(5).to_s

रूबी 1.9+ के लिए

"123".split(//).last(5).join("").to_s

रूबी 2.0+ के लिए, एक स्ट्रिंग लौटें

"123".split(//).last(5).join

Comments

यदि आप रूबी के हालिया संस्करण का उपयोग कर रहे हैं, तो आप charsविभाजन के बजाय उपयोग कर सकते हैं ।

— एंड्रयू ग्रिम

मैंने "12345678910" .plplit (//) का इस्तेमाल किया। अंतिम (7) .join.to_s

— हार्ड

@ हार्ड- BoiledWonderland joinकाम करता है। मुझे नहीं लगता कि to_sअगर आप जुड़ने का उपयोग करते हैं तो आपको अंतिम की आवश्यकता है ।

— एंड्रयू ग्रिम

@AndrewGrimm आप सही हैं, उस स्थिति के लिए मैंने Nokogiri के साथ उपरोक्त प्रयोग किया था, n.xpath('ReferenceID').inner_text.split(//).last(7).join.to_s.to_iमुझे संख्यात्मक मान निकालने के लिए to_i करने के लिए to_s की आवश्यकता थी।

— हार्ड-उबला हुआ वंडरलैंड

आप याद कर रहे हैं .join - अब यह स्ट्रिंग्स की एक सरणी देता है। इसके बजाय यह होना चाहिए "123".split(//).last(5).join(रूबी 2.0.0)

— पावेल निकोलोव

Answer 2

खैर, सबसे आसान समाधान मैं सोच सकता हूं:

ending = str[-n..-1] || str

(EDIT: orऑपरेटर के पास असाइनमेंट की तुलना में कम पूर्वता है, इसलिए ||इसके बजाय उपयोग करना सुनिश्चित करें ।)

Comments

+1 ... मुझे लगता है कि यह तरीका पढ़ने में आसान है string.reverse[0..n].reverse, जो मुझे एक और "प्रतीक्षा करता है, वह ऐसा क्यों कर रहा है?" (या यदि मैं इसे इस प्रश्न के संदर्भ में नहीं पढ़ रहा था)

— Arkaaito

अच्छा जवाब है, लेकिन यह ||इसके बजाय होना चाहिए or, या चारों ओर कोष्ठक डालना चाहिए str[-n..-1] or str।

— एंड्रयू ग्रिम

अच्छा जवाब है, लेकिन मुझे यह पसंद नहीं है कि माणिक s [-inf ..- 1] को x [0..inf] के समान नहीं मानते हैं

— klochner

संचालक पूर्ववर्ती मुद्दे को ध्यान देने के लिए धन्यवाद, एंड्रयू। मुझे हर बार देता है।

— पेरीमोसोकार्डिया

@perimosocordiae आप केवल एक ही नहीं हैं। stackoverflow.com/questions/372652/…

— एंड्रयू ग्रिम

Answer 3

सीधे रूबी (रेल के बिना) में, आप कर सकते हैं

string.chars.last(n).join

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

2.4.1 :009 > a = 'abcdefghij'
 => "abcdefghij"
2.4.1 :010 > a.chars.last(5).join
 => "fghij"
2.4.1 :011 > a.chars.last(100).join
 => "abcdefghij"

यदि आप रूबी ऑन रेल्स का उपयोग कर रहे हैं, तो आप विधियों firstऔर lastएक स्ट्रिंग ऑब्जेक्ट पर कॉल कर सकते हैं । इन तरीकों को पसंद किया जाता है क्योंकि वे रसीले और सहज होते हैं।

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

[1] pry(main)> a = 'abcdefg'                                                                                                                
 => "abcdefg"
[2] pry(main)> a.first(3)                                                                                                                   
 => "abc"
[3] pry(main)> a.last(4)                                                                                                                    
 => "defg"

Comments

रूबी रेल का मतलब नहीं है।

— वोल्ट

Answer 4

ending = string.reverse[0...n].reverse

Comments

यह इस पृष्ठ पर मेरे द्वारा देखा गया सबसे अच्छा तरीका है जो कुल स्ट्रिंग लंबाई से अधिक होने वाली एक समाप्ति वर्ण लंबाई की आपूर्ति करने में सक्षम होने की आवश्यकता को संतुष्ट करता है।

— Rob.Kachmar

उदाहरण के लिए, यदि आप "अब्डे", "अब", और "ए" जैसे डंक के समूह के अंतिम 3 चरित्र को लेने का इरादा कर रहे हैं। इस तकनीक के परिणामस्वरूप "cde", "ab" और "a" प्रत्येक के लिए समान कोड का उपयोग किया जाएगा। "abcde".reverse[0,3].reverse>>> "cde" "ab".reverse[0,3].reverse>>> "ab" "a".reverse[0,3].reverse>>> "a"

— Rob.Kachmar

Answer 5

आप निम्नलिखित कोड का उपयोग कर सकते हैं:

string[string.length-n,string.length]

Comments

केवल कोड - उत्तर हमेशा मददगार नहीं होते हैं। यह बताते हुए कि यह कोड क्यों / कैसे ठीक है, महान होगा

— ry8806

Answer 6

एक स्ट्रिंग से अंतिम n अक्षर प्राप्त करने के लिए, आप ऐसा कर सकते हैं

[a -n, n] अगर ए एरे है।

यहाँ और उदाहरण है अगर आप एक चाहते हैं।

रूबी-1.9.2-p180: 006> a = "911234567890"

=> "911234567890"

रूबी-1.9.2-p180: 009> [-5,5]

=> "67890"

माणिक -1.1.2-p180: 010> [[-7,7]

=> "4567890"

Comments

यदि संख्या बहुत बड़ी है, nilतो वापस कर दिया जाता है, जो कि यह सवाल विशेष रूप से बचने की कोशिश कर रहा था।

— एंड्रयू ग्रिम

अच्छा उत्तर। स्वच्छ।

— Volte

ऐसा क्यों हो रहा है? इसमें ठीक वही समस्या है जो ओपी पूछ रहा था कि कैसे ठीक किया जाए।

— jeffdill2

Answer 7

क्या आपने रेगेक्स की कोशिश की है?

string.match(/(.{0,#{n}}$)/)
ending=$1

रेगेक्स स्ट्रिंग के अंत में जितने भी अक्षर हो सकता है, पकड़ लेता है, लेकिन n से अधिक नहीं। और इसे $ 1 में संग्रहीत करता है।

Answer 8

EmFi के उत्तर पर सुधार।

string[/.{,#{n}}\z/m]