स्ट्रिंग से प्रतिस्थापन निकालें

Question

मैं सोच रहा हूँ कि क्या किसी अन्य स्ट्रिंग से स्ट्रिंग निकालने की कोई विधि है? कुछ इस तरह:

class String
  def remove(s)
    self[s.length, self.length - s.length]
  end
end

Answer 1

आप स्लाइस विधि का उपयोग कर सकते हैं:

a = "foobar"
a.slice! "foo"
=> "foo"
a
=> "bar"

एक गैर है! ' संस्करण के रूप में अच्छी तरह से। अन्य संस्करणों के बारे में प्रलेखन में अधिक जानकारी देखी जा सकती है: http://www.ruby-doc.org/core/classes/String.html#method-i-slice-21

Comments

बहुत खूबसूरत! आप []गैर-बैंग संस्करण के लिए भी एस का उपयोग कर सकते हैं ।

— मथियस मोरेरा

यह हटाए गए पाठ (या खोजे गए पाठ) को वापस करने का एक बुरा दुष्प्रभाव है। विलोपन के परिणाम पर जंजीर के लिए दुर्भाग्यपूर्ण।

— माइक

आप कटा हुआ स्ट्रिंग कैसे लौटाते हैं और मूल को प्रभावित नहीं करते हैं? उदाहरण के लिए यदि मेरे पास "हैलो वर्ल्ड" है, तो मैं "हैलो" को स्लाइस करना चाहता हूं और मूल स्ट्रिंग ऑब्जेक्ट को संशोधित किए बिना, "दुनिया" भाग को वापस करना चाहता हूं?

— झब्बोट

@ माइक"foobar".tap{|s| s.slice!("foo")}.upcase

— अर्नेस्ट

@bcackerman - deleteकाम नहीं करेगा, क्योंकि यह आपके द्वारा पास किए गए सभी वर्णों को हटा देता है:'hello world'.delete('hello') #=> ' wrd'

— rusty

Answer 2

कैसे के बारे str.gsub("subString", "") में रूबी डॉक्टर की जाँच करें

Comments

subकी तुलना में अधिक उपयुक्त होगा gsub, क्योंकि ओपी केवल स्ट्रिंग की शुरुआत से सबस्ट्रिंग को हटाना चाहता है , स्ट्रिंग के माध्यम से नहीं (उसके नमूना कोड को देखें)। और रेगेक्स का उपयोग करना, इस तरह से, बेहतर होगा: str.sub(/^subString/, '')- क्योंकि यह सुनिश्चित करता है कि सबस्ट्रिंग निश्चित रूप से शुरुआत से ही हटा दिया जाएगा।

— एलेक्स डी

@ एएक्सडीडी एक रेगेक्स का उपयोग करना बेहतर होगा, लेकिन यह खतरनाक है अगर हम सुनिश्चित नहीं कर सकते हैं कि subStringइसमें कोई रेगेक्स विशेष वर्ण शामिल नहीं हैं।

— डेविड मोल्स

@DavidMoles, इस मामले में, /^subString/एक शाब्दिक है, इसलिए हम यह सुनिश्चित कर सकते हैं कि इसमें कोई मेटाचैटर शामिल नहीं है। यदि आप किसी अन्य स्ट्रिंग को रेगेक्स में प्रतिस्थापित कर रहे हैं, तो आप यह कर सकते हैं /#{Regexp.escape(str)}/:।

— एलेक्स डी

जवाब में, हां, लेकिन ओपी के सवाल में नहीं। सूचक के लिए धन्यवाद Regexp.escape(), यद्यपि।

— डेविड मोल्स

Answer 3

यदि यह स्ट्रिंग का अंत है, तो आप इसका उपयोग भी कर सकते हैं chomp:

"hello".chomp("llo")     #=> "he"

Comments

अगर अभिव्यक्ति a.chomp ("llo") थी, तो chomp! अधिक सटीक है।

— फर्नांडो गोंजालेज सांचेज

यह टुकड़ा की तुलना में क्लीनर है!, क्योंकि इसका कोई दुष्प्रभाव नहीं है।

— अर्ध अराम

यदि यह स्ट्रिंग की शुरुआत से है, तो आप इसके chompसाथ संयोजन में भी उपयोग कर सकते हैं reverse:"hello".reverse.chomp("he".reverse).reverse #=> "llo"

— amoebe

Answer 4

यदि आपके पास लक्ष्य स्ट्रिंग की केवल एक घटना है, तो आप इसका उपयोग कर सकते हैं:

str[target] = ''

या

str.sub(target, '')

यदि आपके पास लक्ष्य उपयोग की कई घटनाएं हैं:

str.gsub(target, '')

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

asdf = 'foo bar'
asdf['bar'] = ''
asdf #=> "foo "

asdf = 'foo bar'
asdf.sub('bar', '') #=> "foo "
asdf = asdf + asdf #=> "foo barfoo bar"
asdf.gsub('bar', '') #=> "foo foo "

यदि आपको इन-प्लेस प्रतिस्थापन करने की आवश्यकता है तो और के "!"संस्करणों का उपयोग करें ।gsub!sub!

Comments

रूबी मज़ा है! वास्तव में सामान देखने का आनंद लें:asdf['bar'] = ''

— पीटर बटकोविक

मैं उस "मज़े" को गैर-सहज, शायद नहीं कहूंगा।

— Jmoney38

Answer 5

यदि आप रेल का उपयोग कर रहे हैं तो वहां भी remove।

जैसे "Testmessage".remove("message")पैदावार "Test"।

चेतावनी: यह विधि सभी घटनाओं को हटा देती है

Comments

यह एक वेनिला रूबी का जवाब नहीं है, लेकिन स्वीकृत जवाब काफी नहीं है जो अधिकांश लोग ढूंढ रहे हैं। दुर्भाग्य से sliceविधि कताई के उस हिस्से को वापस नहीं करती है, यह "चाकू" लौटाता है

— डायलन पियर्स

@DylanPierce एक फ़ंक्शन को लागू करना बहुत आसान है जो कि उपयोग करता हैslice! def gimme_the_slice(my_string, my_slice) my_string.slice!(my_slice) my_string

— बेनेट टैल्पर्स

आह यह सही है, बैंग-इफिंग है कि रूबी मौजूदा चर को कैसे संशोधित करता है। धन्यवाद @ बेनेटटैलपर्स

— डायलन पियर्स

Answer 6

रूबी 2.5+

यदि आपका विकल्प स्ट्रिंग के अंत में शुरुआत में है, तो रूबी 2.5 ने इसके लिए तरीके पेश किए हैं:

• स्ट्रिंग की शुरुआत से एक विकल्प को हटाने के लिए delete_prefix
• स्ट्रिंग के अंत से एक विकल्प को हटाने के लिए delete_suffix

Answer 7

यदि आप रेल का उपयोग कर रहे हैं या कम एक्टीव्यूअस्पोर्ट पर आपको स्ट्रिंग # हटा दिया गया है और स्ट्रिंग # निकालें! तरीका

def remove!(*patterns)
  patterns.each do |pattern|
    gsub! pattern, ""
  end

  self
end

स्रोत: http://api.rubyonrails.org/classes/String.html#method-i-remove

Answer 8

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

पिछले उत्तरों के विपरीत, मैं ऐसे ऑपरेशन को परिभाषित करने की कोशिश कर रहा हूं जो संपत्ति का पालन करना चाहिए:

IF c = a + b THEN c - a = b और c - b = a

हमें इसे प्राप्त करने के लिए केवल तीन बिल्ट-इन रूबी विधियों की आवश्यकता है:

'abracadabra'.partition('abra').values_at(0,2).join == 'cadabra'।

मैं यह नहीं बताऊंगा कि यह कैसे काम करता है क्योंकि इसे एक बार में एक विधि से आसानी से समझा जा सकता है।

यहाँ अवधारणा कोड का प्रमाण दिया गया है:

# minus_string.rb
class String
  def -(str)
    partition(str).values_at(0,2).join
  end
end

# Add the following code and issue 'ruby minus_string.rb' in the console to test
require 'minitest/autorun'

class MinusString_Test < MiniTest::Test

  A,B,C='abra','cadabra','abracadabra'

  def test_C_eq_A_plus_B
    assert C == A + B
  end

  def test_C_minus_A_eq_B
    assert C - A == B
  end

  def test_C_minus_B_eq_A
    assert C - B == A
  end

end

यदि आप हाल ही में रूबी संस्करण (> = 2.0) का उपयोग कर रहे हैं तो सलाह का एक अंतिम शब्द: पिछले उदाहरण की तरह बंदर-पैचिंग स्ट्रिंग के बजाय शोधन का उपयोग करें ।

यह उतना ही आसान है:

module MinusString
  refine String do
    def -(str)
      partition(str).values_at(0,2).join
    end
  end
end

और using MinusStringउन ब्लॉकों से पहले जोड़ें जहां आपको इसकी आवश्यकता है।

Comments

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

— wondersz1

Answer 9

यहाँ मैं क्या करूँगा

2.2.1 :015 > class String; def remove!(start_index, end_index) (end_index - start_index + 1).times{ self.slice! start_index }; self end; end;
2.2.1 :016 >   "idliketodeleteHEREallthewaytoHEREplease".remove! 14, 32
 => "idliketodeleteplease" 
2.2.1 :017 > ":)".remove! 1,1
 => ":" 
2.2.1 :018 > "ohnoe!".remove! 2,4
 => "oh!" 

कई लाइनों पर प्रारूपित:

class String
    def remove!(start_index, end_index)
        (end_index - start_index + 1).times{ self.slice! start_index }
        self
    end 
end

Answer 10

def replaceslug
  slug = "" + name
    @replacements = [
      [ "," , ""],
      [ "\\?" , ""],
      [ " " , "-"],
      [ "'" , "-"],
      [ "Ç" , "c"],
      [ "Ş" , "s"],
      [ "İ" , "i"],
      [ "I" , "i"],
      [ "Ü" , "u"],
      [ "Ö" , "o"],
      [ "Ğ" , "g"],
      [ "ç" , "c"],
      [ "ş" , "s"],
      [ "ı" , "i"],
      [ "ü" , "u"],
      [ "ö" , "o"],
      [ "ğ" , "g"],
    ]
  @replacements.each do |pair|
    slug.gsub!(pair[0], pair[1])
  end
  self.slug = slug.downcase
end

Comments

इतने नीचे वोट क्यों? आपने क्या गलत किया .. बहुत व्यापक हो सकता है

— zee

ओपी ने Öउदाहरण के लिए हटाने के लिए नहीं कहा ।

— इयूलियन ओनोफ्रेई