Funzione rubino per rimuovere tutti gli spazi bianchi?

Qual è la funzione Ruby per rimuovere tutti gli spazi bianchi? Sto cercando qualcosa di simile a PHP trim()?

Se vuoi rimuovere solo gli spazi bianchi iniziali e finali (come il ritaglio di PHP) puoi usare .strip, ma se vuoi rimuovere tutti gli spazi bianchi, puoi usare .gsub(/\s+/, "")invece.

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

E per emulare la trim()funzione di PHP :

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

Risposta correlata:

"   clean up my edges    ".strip

ritorna

"clean up my edges"

String#strip - rimuovere tutti gli spazi bianchi dall'inizio e dalla fine.

String#lstrip - proprio dall'inizio.

String#rstrip - solo dalla fine.

String#chomp(senza argomenti): elimina i separatori di riga ( \no \r\n) dalla fine.

String#chop - elimina l'ultimo carattere.

String#delete- x.delete(" \t\r\n")- elimina tutti gli spazi bianchi elencati.

String#gsub- x.gsub(/[[:space:]]/, '')- rimuove tutti gli spazi bianchi, compresi quelli Unicode .

Nota : tutti i metodi sopra riportati restituiscono una nuova stringa invece di mutare l'originale. Se si desidera modificare la stringa in atto, chiamare il metodo corrispondente con !alla fine.

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

Elimina funziona più velocemente =)

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)

Se si utilizza Rails / ActiveSupport , è possibile utilizzare il squishmetodo. Rimuove lo spazio bianco su entrambe le estremità della stringa e raggruppa più spazi bianchi in uno spazio singolo.

Per es.

" a  b  c ".squish

risulterà a:

"a b c"

Controlla questo riferimento da api.rubyonrails.org .

È un po 'tardi, ma chiunque altro google su questa pagina potrebbe essere interessato a questa versione:

Se vuoi ripulire un pezzo di testo preformattato che un utente potrebbe aver incollato e incollato in qualche modo nella tua app, ma preservando la spaziatura delle parole, prova questo:

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"

Il .stripmetodo di Ruby esegue l'equivalente in PHP trim().

Per rimuovere tutti gli spazi bianchi:

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

@Tass mi ha fatto sapere che la mia risposta originale rimuove le lettere duplicate in successione - YUCK! Da allora sono passato al metodo squish che è più intelligente su tali eventi se si utilizza il framework Rails.

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

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

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

" Raheem Shaik ".strip

Rimuoverà gli spazi laterali sinistro e destro. Questo codice ci darebbe:"Raheem Shaik"

Inoltre, non dimenticare:

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

split.join farà saltare tutti gli spazi in qualsiasi punto della stringa.

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

È facile da scrivere e ricordare, quindi è carino sulla console e per un hacking rapido. Probabilmente non è il benvenuto in un codice serio anche se maschera l'intento.

(Basato sul commento di Piotr nella risposta di Justicle sopra.)

Potresti provare questo

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

utilizzando : spazio: rimuove lo spazio non interrotto insieme allo spazio normale.

Usa gsub o elimina. La differenza è che gsub potrebbe rimuovere le schede, mentre non è possibile eliminare. A volte sono presenti schede nei file che vengono aggiunti dagli editor.

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"

Esistono molti modi:
Per rimuovere gli spazi bianchi da entrambi i lati:

Tipo di come php's trim ()

Foo_bar.strip

Per rimuovere tutti gli spazi:

Foo_bar.gsub(/ /, "")

Per rimuovere tutti gli spazi bianchi:

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

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

Il metodo gsub andrà bene.
Il metodo gsub può essere chiamato su una stringa e dice:

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

Il metodo gsub cerca ogni occorrenza del primo argomento e lo sostituisce con il secondo argomento. In questo caso, sostituirà ogni spazio all'interno della stringa e lo rimuoverà.

Un altro esempio:

b = "the white fox has a torn tail"

Sostituiamo ogni occorrenza della lettera "t" con una "T" maiuscola

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

Per un comportamento esattamente corrispondente a PHP trim, il metodo più semplice è utilizzare il String#stripmetodo, in questo modo:

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

Ruby ha anche una versione edit-in-place, chiamata anche String.strip!(nota il finale '!'). Ciò non richiede la creazione di una copia della stringa e può essere significativamente più veloce per alcuni usi:

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

Entrambe le versioni producono questo output:

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

Ho creato un benchmark per testare le prestazioni di alcuni usi di base di stripe strip!, nonché alcune alternative. Il test è questo:

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

Questi sono i risultati:

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)

La mia preferenza personale sta usando il metodo .tr

come in:

string = "this is a string to smash together"

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

Grazie a @FrankScmitt per aver sottolineato che per eliminare tutto lo spazio bianco (non solo gli spazi) è necessario scriverlo come tale:

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

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

Stavo provando a farlo perché volevo usare un "titolo" di record come ID nella vista ma i titoli avevano spazi.

una soluzione è:

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

Ruby .scan()e i .join()metodi di String possono anche aiutare a superare gli spazi bianchi nella stringa.

scan(/\w+/).join rimuoverà tutti gli spazi e unirà la stringa

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

Rimuove anche lo spazio dalla parte sinistra e destra della stringa. Mezzi ltrim, rtrime trim. Nel caso in cui qualcuno abbia uno sfondo C, FoxProo Visual Basice salti dentro 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 >

Vorrei usare qualcosa del genere:

my_string = "Foo bar\nbaz quux"

my_string.split.join
=> "Foobarbazquux"

Sono un po 'in ritardo al gioco, ma rimuovo il trailing e i primi spazi bianchi usando strip! . Se disponi di un array, come ho fatto io, ho bisogno di scorrere attraverso l'array e salvarlo al termine dell'istanza. Il ! si è preso cura di questo. Questo ha rimosso tutti gli spazi bianchi alla fine o all'inizio, non solo il primo o l'ultimo finale.

Per esempio:

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

Ciò produrrebbe a: ["ciao", "Melanie", "è", "nuovo", "a", "programmazione"]. Ho ulteriormente esplorato / condiviso questo in un video che ho realizzato per evidenziare questo codice per una domanda simile che avevo .

Sono più recente nella programmazione e l'utilizzo di strip non ha funzionato in quanto non lo ha salvato sull'array dopo la fine del ciclo.

Puoi provare questo:

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

per ottenere questo:

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

o se vuoi una singola stringa, usa semplicemente:

"ab c d efg hi ".split.join