Ruby, rimuovi gli ultimi N caratteri da una stringa?

Qual è il modo preferito di rimuovere gli ultimi ncaratteri da una stringa?

Rubino 2.5+

A partire da Ruby 2.5 è possibile utilizzare delete_suffixo delete_suffix!per raggiungere questo obiettivo in modo rapido e leggibile.

I documenti sui metodi sono qui .

Se sai qual è il suffisso, questo è idiomatico (e direi, ancora più leggibile rispetto alle altre risposte qui):

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

È anche significativamente più veloce (quasi il 40% con il metodo del botto) rispetto alla risposta migliore. Ecco il risultato dello stesso benchmark:

                     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)

Spero che sia utile - nota che il metodo attualmente non accetta una regex, quindi se non conosci il suffisso non è praticabile per il momento. Tuttavia, poiché la risposta accettata ( aggiornamento: al momento della stesura ) impone lo stesso, ho pensato che ciò potesse essere utile ad alcune persone.

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

Se i caratteri che desideri rimuovere sono sempre gli stessi caratteri, considera chomp:

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

I vantaggi di chompsono: nessun conteggio e il codice comunica più chiaramente cosa sta facendo.

Senza argomenti, chomprimuove la fine della riga DOS o Unix, se presente:

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

Dai commenti, c'era una domanda sulla velocità di utilizzo #chomprispetto all'utilizzo di un intervallo. Ecco un benchmark che confronta i due:

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

Risultati benchmark (utilizzando 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)

Quindi chomp è più veloce dell'uso di un intervallo, del ~ 22%.

str = str[0...-n]

io suggerirei chop . Penso che sia stato menzionato in uno dei commenti, ma senza collegamenti o spiegazioni, quindi ecco perché penso che sia meglio:

Rimuove semplicemente l'ultimo carattere da una stringa e non è necessario specificare alcun valore perché ciò accada.

Se devi rimuovere più di un personaggio, allora chompè la soluzione migliore. Questo è ciò che i documenti di Ruby hanno da dire su chop:

Restituisce una nuova stringa con l'ultimo carattere rimosso. Se la stringa termina con \ r \ n, entrambi i caratteri vengono rimossi. L'applicazione di chop a una stringa vuota restituisce una stringa vuota. String # chomp è spesso un'alternativa più sicura, poiché lascia invariata la stringa se non termina in un separatore di record.

Sebbene questo sia usato principalmente per rimuovere separatori come l' \r\nho usato per rimuovere l'ultimo carattere da una semplice stringa, ad esempio sper rendere la parola singolare.

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

Qui nella console:

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

Far cadere gli ultimi npersonaggi equivale a mantenere i primi length - npersonaggi.

Il supporto attivo include String#firste String#lastmetodi che forniscono un modo conveniente per conservare o eliminare il primo / ultimo ncarattere:

require 'active_support/core_ext/string/access'

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

se stai usando le rotaie, prova:

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

[MODIFICATO]

Per ottenere la stringa SENZA gli ultimi 2 caratteri:

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

Nota: l'ultimo carattere stringa è in n-1. Quindi, per rimuovere gli ultimi 2, usiamo n-3.

Puoi sempre usare qualcosa del genere

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

Dove X il numero di caratteri da rimuovere.

O con l'assegnazione / utilizzo del risultato:

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

dove Xè il numero di caratteri più uno da rimuovere.

Dai un'occhiata al slice()metodo:

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

Se stai bene con la creazione di metodi di classe e desideri i personaggi che tagli, prova questo:

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'

Usando regex:

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

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

Se i personaggi che vuoi rimuovere sono sempre gli stessi, prendi in considerazione chomp:

'abc123'. chomp ('123')

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