cadenas - contar caracteres en ruby
Ruby, ¿eliminar los últimos N caracteres de una cadena? (12)
¿Cuál es la forma preferida de eliminar los últimos n caracteres de una cadena?
Echa un vistazo al método slice() :
Eliminar los últimos n caracteres es lo mismo que mantener la primera length - n caracteres.
El soporte activo incluye los métodos String#first y String#last que proporcionan una manera conveniente de mantener o eliminar los primeros / últimos n caracteres:
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 2 últimos 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.
Si estás de acuerdo con la creación de métodos de clase y quieres los caracteres que cortas, prueba 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''
Si los caracteres que desea eliminar son siempre los mismos, entonces considere chomp :
''abc123''.chomp(''123'') # => "abc"
Las ventajas de chomp son: no contar, y el código comunica más claramente lo que está haciendo.
Sin argumentos, chomp elimina el final de línea de DOS o Unix, si alguno de los dos está presente:
"abc/n".chomp # => "abc"
"abc/r/n".chomp # => "abc"
De los comentarios, hubo una pregunta sobre la velocidad de uso de #chomp en lugar de usar un rango. Aquí hay un punto de referencia comparando 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%.
Siempre puedes usar algo como
"string".sub!(/.{X}$/,'''')
Donde X es el número de caracteres a eliminar.
O con asignar / usar el resultado:
myvar = "string"[0..-X]
donde X es el número de caracteres más uno para eliminar.
Usando regex:
str = ''string''
n = 2 #to remove last n characters
str[//A.{#{str.size-n}}/] #=> "stri"
Yo sugeriría chop . Creo que se ha mencionado en uno de los comentarios, pero sin enlaces ni explicaciones, por lo que 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 necesitas eliminar más de un personaje, entonces chomp es tu mejor apuesta. Esto es lo que dicen los doctores ruby sobre el chop :
Devuelve una nueva cadena con el último carácter eliminado. Si la cadena termina con / r / n, ambos caracteres se eliminan. La aplicación de cortar a una cadena vacía devuelve una cadena vacía. String # chomp es a menudo una alternativa más segura, ya que no cambia la cadena si no termina en un separador de registros.
Aunque se usa principalmente para eliminar separadores como /r/n lo he usado para eliminar el último carácter de una cadena simple, por ejemplo, la s para hacer que la palabra sea singular.
irb> ''now is the time''[0...-4]
=> "now is the "
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"
str = str[0...-n]
x = "my_test"
last_char = x.split('''').last