Función Ruby para eliminar todos los espacios en blanco?

¿Cuál es la función Ruby para eliminar todos los espacios en blanco? Estoy buscando algo así como PHP trim()?

Si desea eliminar solo los espacios en blanco iniciales y finales (como el recorte de PHP), puede usarlos .strip, pero si desea eliminar todos los espacios en blanco, puede usarlos .gsub(/\s+/, "")en su lugar.

s = "I have white space".delete(' ')

Y para emular la trim()función de PHP :

s = "   I have leading and trailing white space   ".strip

Respuesta relacionada:

"   clean up my edges    ".strip

devoluciones

"clean up my edges"

String#strip - Eliminar todo el espacio en blanco desde el principio y el final.

String#lstrip - Solo desde el principio.

String#rstrip - Solo desde el final.

String#chomp(sin argumentos): elimina los separadores de línea ( \no \r\n) del final.

String#chop - elimina el último personaje.

String#delete- x.delete(" \t\r\n")- elimina todos los espacios en blanco listados.

String#gsub- x.gsub(/[[:space:]]/, '')- elimina todos los espacios en blanco, incluidos los unicode .

Nota : Todos los métodos anteriores devuelven una nueva cadena en lugar de mutar el original. Si desea cambiar la cadena en su lugar, llame al método correspondiente con !al final.

"1232 23 2 23 232 232".delete(' ')
=> "123223223232232"

Eliminar funciona más rápido =)

user         system     total      real
gsub, s      0.180000   0.010000   0.190000 (0.193014)
gsub, s+     0.200000   0.000000   0.200000 (0.196408)
gsub, space  0.220000   0.000000   0.220000 (0.222711)
gsub, join   0.200000   0.000000   0.200000 (0.193478)
delete       0.040000   0.000000   0.040000 (0.045157)

Si está utilizando Rails / ActiveSupport , puede usar el squishmétodo. Elimina el espacio en blanco en ambos extremos de la cadena y agrupa múltiples espacios en blanco en un solo espacio.

Por ej.

" a  b  c ".squish

resultará en:

"a b c"

Verifique esta referencia de api.rubyonrails.org .

Es un poco tarde, pero cualquier otra persona que busque en Google esta página podría estar interesada en esta versión.

Si desea limpiar una porción de texto preformateado que un usuario puede haber cortado y pegado en su aplicación de alguna manera, pero preservar el espacio entre palabras, intente esto:

content = "      a big nasty          chunk of     something

that's been pasted                        from a webpage       or something        and looks 

like      this

"

content.gsub(/\s+/, " ").strip

#=> "a big nasty chunk of something that's been pasted from a webpage or something and looks like this"

El .stripmétodo de Ruby realiza el equivalente de PHP atrim() .

Para eliminar todos los espacios en blanco:

"  leading    trailing   ".squeeze(' ').strip
=> "leading trailing"

@Tass me hizo saber que mi respuesta original elimina las letras duplicadas en sucesión - ¡YUCK! Desde entonces, cambié al método de compresión que es más inteligente sobre tales ocurrencias si utilizo el marco Rails.

require 'active_support/all'
"  leading    trailing   ".squish
=> "leading trailing"

"  good    men   ".squish
=> "good men"

Cita: http://apidock.com/rails/String/squish

" Raheem Shaik ".strip

Eliminará los espacios laterales izquierdo y derecho. Este código nos daría:"Raheem Shaik"

Tampoco olvides:

$ s = "   I have white space   ".split
=> ["I", "have", "white", "space"]

split.join explotará todos los espacios en cualquier lugar de la cadena.

"  a b  c    d     ".split.join
> "abcd"

Es fácil de escribir y recordar, por lo que es agradable en la consola y para un pirateo rápido. Podría decirse que no es bienvenido en un código serio, ya que oculta la intención.

(Basado en el comentario de Piotr en la respuesta de Justicle arriba).

Podrías probar esto

"Some Special Text Values".gsub(/[[:space:]]+/, "")

utilizando : espacio: elimina el espacio que no se rompe junto con el espacio normal.

Usa gsub o delete. La diferencia es que gsub podría eliminar pestañas, mientras que eliminar no puede. A veces tienes pestañas en los archivos que los editores agregan.

a = "\tI have some whitespaces.\t"
a.gsub!(/\s/, '')  #=>  "Ihavesomewhitespaces."
a.gsub!(/ /, '')   #=>  "\tIhavesomewhitespaces.\t"
a.delete!(" ")     #=>  "\tIhavesomewhitespaces.\t"
a.delete!("/\s/")  #=>  "\tIhavesomewhitespaces.\t"
a.delete!('/\s/')  #=>  using single quote is unexpected, and you'll get "\tI have ome whitepace.\t"

Hay muchas formas:
para eliminar espacios en blanco de ambos lados:

Algo así como el ajuste de php ()

Foo_bar.strip

Para eliminar todos los espacios:

Foo_bar.gsub(/ /, "")

Para eliminar todos los espacios en blanco:

Foo_bar.gsub(/\s/, "")

"asd sda sda sd".gsub(' ', '')
=> "asdsdasdasd"

El método gsub funcionará bien.
El método gsub se puede invocar en una cadena y dice:

a = "this is a string"
a = a.gsub(" ","")
puts a
#Output: thisisastring

El método gsub busca cada aparición del primer argumento y lo reemplaza con el segundo argumento. En este caso, reemplazará cada espacio dentro de la cadena y lo eliminará.

Otro ejemplo:

b = "the white fox has a torn tail"

Reemplacemos cada aparición de la letra "t" con una "T" mayúscula

b = b.gsub("t","T")
puts b 
#Output: The whiTe fox has a Torn Tail

Para un comportamiento que coincida exactamente con PHP trim, el método más simple es usar el String#stripmétodo, así:

string = "  Many have tried; many have failed!    "
puts "Original [#{string}]:#{string.length}"
new_string = string.strip
puts "Updated  [#{new_string}]:#{new_string.length}"

Ruby también tiene una versión de edición en el lugar, también llamada String.strip!(tenga en cuenta el final '!'). Esto no requiere crear una copia de la cadena, y puede ser significativamente más rápido para algunos usos:

string = "  Many have tried; many have failed!    "
puts "Original [#{string}]:#{string.length}"
string.strip!
puts "Updated  [#{string}]:#{string.length}"

Ambas versiones producen esta salida:

Original [  Many have tried; many have failed!    ]:40
Updated  [Many have tried; many have failed!]:34

Creé un punto de referencia para probar el rendimiento de algunos usos básicos de stripy strip!, así como algunas alternativas. La prueba es esta:

require 'benchmark'

string = 'asdfghjkl'
Times = 25_000

a = Times.times.map {|n| spaces = ' ' * (1+n/4); "#{spaces}#{spaces}#{string}#{spaces}" }
b = Times.times.map {|n| spaces = ' ' * (1+n/4); "#{spaces}#{spaces}#{string}#{spaces}" }
c = Times.times.map {|n| spaces = ' ' * (1+n/4); "#{spaces}#{spaces}#{string}#{spaces}" }
d = Times.times.map {|n| spaces = ' ' * (1+n/4); "#{spaces}#{spaces}#{string}#{spaces}" }

puts RUBY_DESCRIPTION
puts "============================================================"
puts "Running tests for trimming strings"

Benchmark.bm(20) do |x|
  x.report("s.strip:")                 { a.each {|s| s = s.strip } }
  x.report("s.rstrip.lstrip:")         { a.each {|s| s = s.rstrip.lstrip } }
  x.report("s.gsub:")                  { a.each {|s| s = s.gsub(/^\s+|\s+$/, "") } }
  x.report("s.sub.sub:")               { a.each {|s| s = s.sub(/^\s+/, "").sub(/\s+$/, "") } }

  x.report("s.strip!")                 { a.each {|s| s.strip! } }
  x.report("s.rstrip!.lstrip!:")       { b.each {|s| s.rstrip! ; s.lstrip! } }
  x.report("s.gsub!:")                 { c.each {|s| s.gsub!(/^\s+|\s+$/, "") } }
  x.report("s.sub!.sub!:")             { d.each {|s| s.sub!(/^\s+/, "") ; s.sub!(/\s+$/, "") } }
end

Estos son los resultados:

ruby 2.2.5p319 (2016-04-26 revision 54774) [x86_64-darwin14]
============================================================
Running tests for trimming strings
                           user     system      total        real
s.strip:               2.690000   0.320000   3.010000 (  4.048079)
s.rstrip.lstrip:       2.790000   0.060000   2.850000 (  3.110281)
s.gsub:               13.060000   5.800000  18.860000 ( 19.264533)
s.sub.sub:             9.880000   4.910000  14.790000 ( 14.945006)
s.strip!               2.750000   0.080000   2.830000 (  2.960402)
s.rstrip!.lstrip!:     2.670000   0.320000   2.990000 (  3.221094)
s.gsub!:              13.410000   6.490000  19.900000 ( 20.392547)
s.sub!.sub!:          10.260000   5.680000  15.940000 ( 16.411131)

Mi preferencia personal es usar el método .tr

como en:

string = "this is a string to smash together"

string.tr(' ', '') # => "thisisastringtosmashtogether"

Gracias a @FrankScmitt por señalar que para hacer que esto elimine todos los espacios en blanco (no solo los espacios), deberá escribirlo como tal:

string = "this is a string with tabs\t and a \nnewline"

string.tr(" \n\t", '') # => "thisisastringwithtabsandanewline"

Estaba tratando de hacer esto porque quería usar un "título" de registros como id en la vista, pero los títulos tenían espacios.

una solución es:

record.value.delete(' ') # Foo Bar -> FooBar

Ruby .scan()y los .join()métodos de String también pueden ayudar a superar los espacios en blanco en la cadena.

scan(/\w+/).join eliminará todos los espacios y unirá la cadena

string = "White spaces in me".scan(/\w+/).join
=>"Whitespacesinme"

También está eliminando espacio de la parte izquierda y derecha de la cadena. Medios ltrim, rtrimy trim. Por si acaso, si alguien tiene más de fondo C, FoxProo Visual Basicy saltar en Ruby.

2.1.6 :002 > string = " White spaces in me ".scan(/\w+/).join => "Whitespacesinme" 2.1.6 :003 > string = " White spaces in me".scan(/\w+/).join => "Whitespacesinme" 2.1.6 :004 > string = "White spaces in me ".scan(/\w+/).join => "Whitespacesinme" 2.1.6 :005 >

Yo usaría algo como esto:

my_string = "Foo bar\nbaz quux"

my_string.split.join
=> "Foobarbazquux"

Llego un poco tarde al juego, pero elimino los espacios en blanco iniciales y finales mediante el uso de strip! . Si tiene una matriz, como yo, necesitaba iterar a través de la matriz y guardarla después de que finalizara la instancia. Los ! se encargó de esto. Esto eliminó todos los espacios en blanco al final o al principio, no solo el primer inicio o el último final.

Por ejemplo:

array = ["hello ","   Melanie", "is", " new ", "to  ", " programming"]
array.each do |i|
  i.strip!
end

Esto daría como resultado: ["hola", "Melanie", "es", "nuevo", "a", "programación"]. Exploré / compartí esto en un video que hice para resaltar este código para una pregunta similar que tenía .

Soy nuevo en la programación y el uso de strip no funcionó, ya que no lo guardó en la matriz después de que finalizó el ciclo.

Puedes probar esto:

"ab c d efg hi ".split.map(&:strip)

para obtener esto:

["ab, "c", "d", "efg", "hi"]

o si quieres una sola cadena, solo usa:

"ab c d efg hi ".split.join