Ruby, ¿eliminar los últimos N caracteres de una cadena?

¿Cuál es la forma preferida de eliminar los últimos ncaracteres de una cadena?

Ruby 2.5+

A partir de Ruby 2.5, puede usar delete_suffixo delete_suffix!lograr esto de manera rápida y fácil de leer.

Los documentos sobre los métodos están aquí .

Si sabes cuál es el sufijo, esto es idiomático (y argumentaría, aún más legible que otras respuestas aquí):

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

Es incluso significativamente más rápido (casi 40% con el método de explosión) que la respuesta principal. Aquí está el resultado del mismo punto de referencia:

                     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)

Espero que esto sea útil: tenga en cuenta que el método no acepta actualmente una expresión regular, por lo que si no conoce el sufijo no es viable por el momento. Sin embargo, como la respuesta aceptada ( actualización: al momento de escribir ) dicta lo mismo, pensé que esto podría ser útil para algunas personas.

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

Si los caracteres que desea eliminar son siempre los mismos, considere chomp:

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

Las ventajas de chompson: sin contar, y el código comunica más claramente lo que está haciendo.

Sin argumentos, chompelimina el final de línea de DOS o Unix, si alguno está presente:

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

A partir de los comentarios, hubo una pregunta sobre la velocidad de usar #chompversus usar un rango. Aquí hay un punto de referencia que compara los dos:

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

Resultados de referencia (utilizando 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)

Entonces chomp es más rápido que usar un rango, en ~ 22%.

str = str[0...-n]

Yo sugeriría chop. Creo que se ha mencionado en uno de los comentarios pero sin enlaces ni explicaciones, así que he aquí por qué creo que es mejor:

Simplemente elimina el último carácter de una cadena y no tiene que especificar ningún valor para que eso suceda.

Si necesita eliminar más de un personaje, entonces chompes su mejor apuesta. Esto es lo que los documentos de Ruby tienen que decir sobre chop:

Devuelve una nueva cadena con el último carácter eliminado. Si la cadena termina con \ r \ n, ambos caracteres se eliminan. Aplicar chop a una cadena vacía devuelve una cadena vacía. String # chomp es a menudo una alternativa más segura, ya que deja la cadena sin cambios si no termina en un separador de registros.

Aunque esto se usa principalmente para eliminar separadores, como \r\nlo he usado para eliminar el último carácter de una cadena simple, por ejemplo, spara hacer que la palabra sea singular.

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

Aquí en la consola:

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

Dejar caer los últimos ncaracteres es lo mismo que conservar los primeros length - ncaracteres.

El Soporte activo incluye String#firsty String#lastmétodos que proporcionan una manera conveniente de mantener o soltar el primer / último ncarácter:

require 'active_support/core_ext/string/access'

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

Si está utilizando rieles, intente:

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

[EDITADO]

Para obtener la cadena SIN los últimos 2 caracteres:

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

Nota: la última cadena de caracteres está en n-1. Entonces, para eliminar los últimos 2, usamos n-3.

Siempre puedes usar algo como

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

¿Dónde Xestá el número de caracteres para eliminar?

O con la asignación / uso del resultado:

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

donde Xes el número de caracteres más uno para eliminar.

Mira el slice()método:

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

Si está de acuerdo con la creación de métodos de clase y desea los caracteres que corta, intente esto:

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"

Si los caracteres que desea eliminar son siempre los mismos, considere chomp:

'abc123'. chomp ('123')

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