Xóa chuỗi con khỏi chuỗi

Tôi chỉ tự hỏi nếu có bất kỳ phương pháp để loại bỏ chuỗi từ một chuỗi khác? Một cái gì đó như thế này:

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

Bạn có thể sử dụng phương pháp lát:

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

không có '!' phiên bản là tốt. Cũng có thể xem thêm thông tin trong tài liệu về các phiên bản khác: http://www.ruby-doc.org/core/groupes/String.html#method-i-slice-21

Làm thế nào về str.gsub("subString", "") Kiểm tra Ruby Doc

Nếu nó là phần cuối của chuỗi, bạn cũng có thể sử dụng chomp:

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

Nếu bạn chỉ có một lần xuất hiện của chuỗi mục tiêu, bạn có thể sử dụng:

str[target] = ''

hoặc là

str.sub(target, '')

Nếu bạn có nhiều lần sử dụng mục tiêu:

str.gsub(target, '')

Ví dụ:

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 "

Nếu bạn cần thay thế tại chỗ, hãy sử dụng các "!"phiên bản gsub!và sub!.

Nếu bạn đang sử dụng Rails cũng có remove.

Ví dụ "Testmessage".remove("message")sản lượng "Test".

Cảnh báo: phương pháp này loại bỏ tất cả các lần xuất hiện

Ruby 2.5+

Nếu chuỗi con của bạn ở đầu chuỗi cuối, thì Ruby 2.5 đã giới thiệu các phương thức cho việc này:

• xóa_prefix để xóa một chuỗi con từ đầu chuỗi
• xóa_suffix để xóa một chuỗi con khỏi cuối chuỗi

Nếu bạn đang sử dụng đường ray hoặc ít hỗ trợ hơn, bạn có String # remove và String # remove! phương pháp

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

  self
end

nguồn: http://api.rubyonrails.org/groupes/String.html#method-i-remove

Nếu tôi giải thích đúng, câu hỏi này dường như yêu cầu một cái gì đó giống như một phép toán trừ (-) giữa các chuỗi, tức là ngược lại với phép toán cộng (+) tích hợp (nối).

Không giống như các câu trả lời trước, tôi đang cố gắng xác định một hoạt động như vậy phải tuân theo thuộc tính:

NẾU c = a + b THEN c - a = b VÀ c - b = a

Chúng tôi chỉ cần ba phương thức Ruby tích hợp để đạt được điều này:

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

Tôi sẽ không giải thích cách nó hoạt động bởi vì có thể dễ dàng hiểu được khi chạy một phương thức tại một thời điểm.

Dưới đây là một bằng chứng về mã khái niệm:

# 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

Một lời khuyên cuối cùng nếu bạn đang sử dụng phiên bản Ruby gần đây (> = 2.0): sử dụng các sàng lọc thay vì Chuỗi vá khỉ như trong ví dụ trước.

Nó dễ dàng như:

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

và thêm using MinusStringtrước các khối nơi bạn cần nó.

đây là những gì tôi sẽ làm

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

Được định dạng trên nhiều dòng:

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