रूबी में एक स्ट्रिंग से विशिष्ट वर्ण कैसे हटाएं?

85

मेरे पास कई तार हैं जो इस तरह दिखते हैं:

"((String1))"

वे सभी अलग-अलग लंबाई के हैं। मैं इन सभी तारों से कोष्ठक को एक पाश में कैसे निकाल सकता हूं?

ruby string trim

— क्रिस्टियानो
स्रोत

2

कोष्ठक हटाएं, या "यादृच्छिक" स्ट्रिंग से पहले दो और अंतिम दो वर्ण निकालें? (वास्तव में यादृच्छिक?)

— मोनिका को बहाल करना - notmaynard

"((String1))" [2 ...- 2] # => "String1"

— मोनिका को पुनः स्थापित करें - notmaynard

1

ruby-doc.org/core-1.9.3/String.html

— मोनिका को फिर से स्थापित करें - notmaynard

आप कई स्ट्रिंग को बदलने के लिए एक लूप के लिए पूछ रहे हैं, तार कैसे संग्रहीत किए जाते हैं?

— हीरोलॉ

मुझे पता है कि मैं सभी तारों के माध्यम से एक लूप बनाने के लिए मैं सिर्फ स्ट्रिंग हेरफेर भाग चाहता था, मुझे खेद है कि अजीब

— क्रिस्टियानो

168

नीचे का उपयोग कर के रूप में String#tr:

 "((String1))".tr('()', '')
 # => "String1"

— अरूप रक्षित
स्रोत

7

एक विनाशकारी संस्करण भी है जो tr!एक स्ट्रिंग को जगह में संशोधित करेगा, जैसेmy_string.tr!(')(','')

— bonh

8

ध्यान दें कि यह फ़ंक्शन शुरुआत या अंत से ट्रिमिंग नहीं है, लेकिन स्ट्रिंग के भीतर सभी पाठ पर एक पूर्ण प्रतिस्थापन है।

— जॉर्डन

3

भ्रामक और गलत। Tr एक ट्रिमिंग फ़ंक्शन नहीं है, यह एक प्रतिस्थापन फ़ंक्शन है। दोनों बहुत अलग ऑपरेशन हैं।

— ज़ेन का दावा

1

@ZaneClaes हाँ। ओपी ने गलत शब्द का इस्तेमाल यह समझाने के लिए किया कि वास्तव में ओपी क्या चाहता है। उत्तर ने दिखाया है कि आउटपुट कैसे प्राप्त करें।

— अरुप रक्षित

42

यदि आप पहले दो वर्णों और अंतिम दो को निकालना चाहते हैं, तो आप स्ट्रिंग पर नकारात्मक अनुक्रमित का उपयोग कर सकते हैं :

s = "((String1))"
s = s[2...-2]
p s # => "String1"

यदि आप स्ट्रिंग से सभी कोष्ठक हटाना चाहते हैं, तो आप स्ट्रिंग कक्षा पर डिलीट विधि का उपयोग कर सकते हैं :

s = "((String1))"
s.delete! '()'
p s #  => "String1"

— JBR
स्रोत

8

यह सभी कोष्ठकों को हटा देगा, यहां तक कि स्ट्रिंग के बीच में भी, जो (प्रतीत होता है) वह नहीं है जो ओपी चाहता है। अगर ऐसा है, तो यही सबसे सुंदर उपाय है।

— मोनिका को बहाल करें - notmaynard

22

इसके पार आने वालों और प्रदर्शन की तलाश में, यह जैसा दिखता है #deleteऔर #trगति में लगभग समान है और 2-4x से अधिक तेज है gsub।

text = "Here is a string with / some forwa/rd slashes"
tr = Benchmark.measure { 10000.times { text.tr('/', '') } }
# tr.total => 0.01
delete = Benchmark.measure { 10000.times { text.delete('/') } }
# delete.total => 0.01
gsub = Benchmark.measure { 10000.times { text.gsub('/', '') } }
# gsub.total => 0.02 - 0.04

— daino3
स्रोत

3

चार साल बाद ... :-) अगर मैं आपकी बेंचमार्किंग को परिमाण (1_000_000 रन) के एक जोड़े के क्रम से देखता हूं, तो उसी कोड के साथ जो आप ऊपर उपयोग करते हैं, मुझे लगता है कि ट्र के मुकाबले थोड़ा तेज चल रहा है, के बारे में डिलीट tr का 0.92 अनुपात, और gsub को हटाने के 1.5x से थोड़ा कम (वास्तव में ~ 1.46 का डिलीट, और ~ 1.39 का tr)। ymmv बेशक। यह 2018 MBP पर रूबी 2.6.3 पर है। इन तीन तरीकों को बेंचमार्क करने के लिए धन्यवाद!

— इसी तरह

21

String#gsubनियमित अभिव्यक्ति के साथ प्रयोग करना :

"((String1))".gsub(/^\(+|\)+$/, '')
# => "String1"
"(((((( parentheses )))".gsub(/^\(+|\)+$/, '')
# => " parentheses "

यह केवल आसपास के कोष्ठकों को हटा देगा।

"(((((( This (is) string )))".gsub(/^\(+|\)+$/, '')
# => " This (is) string "

— falsetru
स्रोत

2

दूसरे उदाहरण के लिए +1 (केवल आसपास के कोष्ठक हटाएं)।

— भवनीत सिंह बाजवा

1

यहाँ इसे प्राप्त करने का एक छोटा तरीका है:

1) का उपयोग कर Negative character class pattern matching

irb(main)> "((String1))"[/[^()]+/]
=> "String1"

^- चरित्र वर्ग में कुछ भी मेल नहीं खाता। चरक वर्ग के अंदर, हमारे पास है (और)

या वैश्विक प्रतिस्थापन "AKA: gsub" के साथ जैसे अन्य लोगों ने उल्लेख किया है।

irb(main)> "((String1))".gsub(/[)(]/, '')
=> "String1"

— z एटफ
स्रोत

आपके दो उत्तरों के अलग-अलग परिणाम हैं ((a))b। पहला केवल वापस आ जाएगा a, दूसरा वापस आ जाएगाab

— उलेसे बीएन