Entfernen Sie die Teilzeichenfolge aus der Zeichenfolge

Ich frage mich nur, ob es eine Methode gibt, um eine Zeichenfolge aus einer anderen Zeichenfolge zu entfernen. Etwas wie das:

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

Sie können die Slice-Methode verwenden:

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

es gibt ein nicht '!' Version auch. Weitere Informationen finden Sie auch in der Dokumentation zu anderen Versionen: http://www.ruby-doc.org/core/classes/String.html#method-i-slice-21

Wie wäre es mit str.gsub("subString", "") dem Ruby Doc

Wenn es das Ende der Zeichenfolge ist, können Sie auch Folgendes verwenden chomp:

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

Wenn Sie nur ein Vorkommen der Zielzeichenfolge haben, können Sie Folgendes verwenden:

str[target] = ''

oder

str.sub(target, '')

Wenn Sie mehrere Ziele verwenden:

str.gsub(target, '')

Zum Beispiel:

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 "

Wenn Sie direkte Ersetzungen vornehmen müssen, verwenden Sie die "!"Versionen von gsub!und sub!.

Wenn Sie Rails verwenden, gibt es auch remove.

ZB "Testmessage".remove("message")ergibt "Test".

Warnung: Diese Methode entfernt alle Vorkommen

Ruby 2.5+

Wenn sich Ihre Teilzeichenfolge am Anfang am Ende einer Zeichenfolge befindet, hat Ruby 2.5 die folgenden Methoden eingeführt:

• delete_prefix zum Entfernen eines Teilstrings vom Anfang der Zeichenfolge
• delete_suffix zum Entfernen eines Teilstrings vom Ende der Zeichenfolge

Wenn Sie Schienen verwenden oder weniger aktiv sind, erhalten Sie String # remove und String # remove! Methode

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

  self
end

Quelle: http://api.rubyonrails.org/classes/String.html#method-i-remove

Wenn ich richtig interpretiere, scheint diese Frage nach einer Minusoperation (-) zwischen Zeichenfolgen zu fragen, dh nach dem Gegenteil der integrierten Plusoperation (+) (Verkettung).

Im Gegensatz zu den vorherigen Antworten versuche ich, eine solche Operation zu definieren, die der Eigenschaft gehorchen muss:

WENN c = a + b DANN c - a = b UND c - b = a

Wir benötigen nur drei integrierte Ruby-Methoden, um dies zu erreichen:

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

Ich werde nicht erklären, wie es funktioniert, da es leicht zu verstehen ist, jeweils eine Methode auszuführen.

Hier ist ein Proof-of-Concept-Code:

# 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

Ein letzter Ratschlag, wenn Sie eine aktuelle Ruby-Version verwenden (> = 2.0): Verwenden Sie Verfeinerungen anstelle von Affen-Patching-Zeichenfolgen wie im vorherigen Beispiel.

Es ist so einfach wie:

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

und fügen Sie using MinusStringvor den Blöcken hinzu, wo Sie es brauchen.

Hier ist was ich tun würde

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!" 

In mehreren Zeilen formatiert:

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

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