Ruby, loại bỏ N ký tự cuối cùng khỏi một chuỗi?

Cách ưa thích để loại bỏ các nký tự cuối cùng khỏi một chuỗi là gì?

Ruby 2.5+

Kể từ Ruby 2.5, bạn có thể sử dụng delete_suffixhoặc delete_suffix!để đạt được điều này một cách nhanh chóng và dễ đọc.

Các tài liệu về các phương pháp là ở đây .

Nếu bạn biết hậu tố là gì, thì đây là thành ngữ (và tôi tranh luận, thậm chí còn dễ đọc hơn các câu trả lời khác ở đây):

'abc123'.delete_suffix('123')     # => "abc"
'abc123'.delete_suffix!('123')    # => "abc"

Nó thậm chí còn nhanh hơn đáng kể (gần 40% với phương pháp bang) so với câu trả lời hàng đầu. Đây là kết quả của cùng một điểm chuẩn:

                     user     system      total        real
chomp            0.949823   0.001025   0.950848 (  0.951941)
range            1.874237   0.001472   1.875709 (  1.876820)
delete_suffix    0.721699   0.000945   0.722644 (  0.723410)
delete_suffix!   0.650042   0.000714   0.650756 (  0.651332)

Tôi hy vọng điều này hữu ích - lưu ý rằng phương thức hiện không chấp nhận regex vì vậy nếu bạn không biết hậu tố thì hiện tại nó không khả thi. Tuy nhiên, vì câu trả lời được chấp nhận ( cập nhật: tại thời điểm viết ) cũng giống như vậy, tôi nghĩ rằng điều này có thể hữu ích với một số người.

irb> 'now is the time'[0...-4]
=> "now is the "

Nếu các ký tự bạn muốn xóa luôn là các ký tự giống nhau, thì hãy xem xét chomp:

'abc123'.chomp('123')    # => "abc"

Ưu điểm của chomplà: không đếm và mã thông báo rõ hơn những gì nó đang làm.

Không có đối số, chomploại bỏ kết thúc dòng DOS hoặc Unix, nếu có mặt:

"abc\n".chomp      # => "abc"
"abc\r\n".chomp    # => "abc"

Từ các ý kiến, đã có một câu hỏi về tốc độ sử dụng #chompso với sử dụng một phạm vi. Đây là một điểm chuẩn so sánh hai:

require 'benchmark'

S = 'asdfghjkl'
SL = S.length
T = 10_000
A = 1_000.times.map { |n| "#{n}#{S}" }

GC.disable

Benchmark.bmbm do |x|
  x.report('chomp') { T.times { A.each { |s| s.chomp(S) } } }
  x.report('range') { T.times { A.each { |s| s[0...-SL] } } }
end

Kết quả điểm chuẩn (sử dụng CRuby 2.13p242):

Rehearsal -----------------------------------------
chomp   1.540000   0.040000   1.580000 (  1.587908)
range   1.810000   0.200000   2.010000 (  2.011846)
-------------------------------- total: 3.590000sec

            user     system      total        real
chomp   1.550000   0.070000   1.620000 (  1.610362)
range   1.970000   0.170000   2.140000 (  2.146682)

Vì vậy, chomp nhanh hơn so với sử dụng một phạm vi, bằng ~ 22%.

str = str[0...-n]

Tôi sẽ đề nghị chop. Tôi nghĩ rằng nó đã được đề cập trong một trong những bình luận nhưng không có liên kết hoặc giải thích vì vậy đây là lý do tại sao tôi nghĩ nó tốt hơn:

Nó chỉ đơn giản là xóa ký tự cuối cùng khỏi một chuỗi và bạn không phải chỉ định bất kỳ giá trị nào cho điều đó xảy ra.

Nếu bạn cần loại bỏ nhiều hơn một ký tự thì đó chomplà đặt cược tốt nhất của bạn. Đây là những gì các tài liệu ruby phải nói về chop:

Trả về một Chuỗi mới với ký tự cuối cùng bị xóa. Nếu chuỗi kết thúc bằng \ r \ n, cả hai ký tự sẽ bị xóa. Áp dụng chop vào một chuỗi rỗng trả về một chuỗi rỗng. Chuỗi # chomp thường là một sự thay thế an toàn hơn, vì nó không thay đổi chuỗi nếu nó không kết thúc bằng dấu tách.

Mặc dù điều này được sử dụng chủ yếu để xóa các dấu phân cách như \r\ntôi đã sử dụng nó để xóa ký tự cuối cùng khỏi một chuỗi đơn giản, ví dụ: sđể tạo từ số ít.

name = "my text"
x.times do name.chop! end

Ở đây trong bảng điều khiển:

>name = "Nabucodonosor"
 => "Nabucodonosor" 
> 7.times do name.chop! end
 => 7 
> name
 => "Nabuco" 

Bỏ các nký tự cuối cùng cũng giống như giữ các length - nký tự đầu tiên .

Hỗ trợ tích cực bao gồm String#firstvà String#lastcác phương thức cung cấp một cách thuận tiện để giữ hoặc xóa các nký tự đầu tiên / cuối cùng :

require 'active_support/core_ext/string/access'

"foobarbaz".first(3)  # => "foo"
"foobarbaz".first(-3) # => "foobar"
"foobarbaz".last(3)   # => "baz"
"foobarbaz".last(-3)  # => "barbaz"

nếu bạn đang sử dụng đường ray, hãy thử:

"my_string".last(2) # => "ng"

[EDITED]

Để có được chuỗi KHÔNG CÓ 2 ký tự cuối cùng:

n = "my_string".size
"my_string"[0..n-3] # => "my_stri"

Lưu ý: char chuỗi cuối cùng là ở n-1. Vì vậy, để loại bỏ 2 cuối cùng, chúng tôi sử dụng n-3.

Bạn luôn có thể sử dụng một cái gì đó như

 "string".sub!(/.{X}$/,'')

Trong trường hợp Xlà số ký tự để loại bỏ.

Hoặc với việc gán / sử dụng kết quả:

myvar = "string"[0..-X]

trong đó Xsố lượng ký tự cộng với một ký tự để loại bỏ.

Kiểm tra slice()phương pháp:

http://ruby-doc.org/core-2.5.0/String.html#method-i-slice

Nếu bạn ổn với việc tạo các phương thức lớp và muốn các ký tự bạn cắt ra, hãy thử điều này:

class String
  def chop_multiple(amount)
    amount.times.inject([self, '']){ |(s, r)| [s.chop, r.prepend(s[-1])] }
  end
end

hello, world = "hello world".chop_multiple 5
hello #=> 'hello '
world #=> 'world'

Sử dụng regex:

str = 'string'
n = 2  #to remove last n characters

str[/\A.{#{str.size-n}}/] #=> "stri"

Nếu các ký tự bạn muốn xóa luôn là các ký tự giống nhau, thì hãy xem xét chomp:

'abc123'. chomp ('123')

x = "my_test"
last_char = x.split('').last