Ruby-Funktion zum Entfernen aller Leerzeichen?

Was ist die Ruby-Funktion, um alle Leerzeichen zu entfernen ? Ich suche so etwas wie PHPs trim()?

Wenn Sie nur führende und nachfolgende Leerzeichen entfernen möchten (wie das Trimmen von PHP), können Sie diese verwenden .strip. Wenn Sie jedoch alle Leerzeichen entfernen möchten , können Sie .gsub(/\s+/, "")stattdessen verwenden.

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

Und um die PHP- trim()Funktion zu emulieren :

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

Verwandte Antwort:

"   clean up my edges    ".strip

kehrt zurück

"clean up my edges"

String#strip - Entfernen Sie alle Leerzeichen vom Anfang und vom Ende.

String#lstrip - Nur von Anfang an.

String#rstrip - Nur vom Ende.

String#chomp(ohne Argumente) - löscht Zeilentrennzeichen ( \noder \r\n) am Ende.

String#chop - löscht das letzte Zeichen.

String#delete- x.delete(" \t\r\n")- löscht alle aufgelisteten Leerzeichen.

String#gsub- x.gsub(/[[:space:]]/, '')- entfernt alle Leerzeichen, einschließlich Unicode- Leerzeichen .

Hinweis : Alle oben genannten Methoden geben eine neue Zeichenfolge zurück, anstatt das Original zu mutieren. Wenn Sie die Zeichenfolge an Ort und Stelle ändern möchten, rufen Sie !am Ende die entsprechende Methode mit auf.

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

Löschen funktioniert schneller =)

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)

Wenn Sie Rails / ActiveSupport verwenden , können Sie die squishMethode verwenden. Es entfernt Leerzeichen an beiden Enden der Zeichenfolge und gruppiert mehrere Leerzeichen zu einem einzelnen Leerzeichen.

Zum Beispiel.

" a  b  c ".squish

ergibt sich zu:

"a b c"

Überprüfen Sie diese Referenz von api.rubyonrails.org .

Es ist ein bisschen spät, aber jeder andere, der diese Seite googelt, könnte an dieser Version interessiert sein -

Wenn Sie einen Teil des vorformatierten Textes bereinigen möchten, den ein Benutzer möglicherweise irgendwie ausgeschnitten und in Ihre App eingefügt hat, aber den Wortabstand beibehalten möchten, versuchen Sie Folgendes:

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"

Rubys .stripMethode führt das PHP-Äquivalent zu aus trim().

So entfernen Sie alle Leerzeichen:

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

@Tass hat mich darauf aufmerksam gemacht, dass meine ursprüngliche Antwort doppelte Buchstaben nacheinander entfernt - YUCK! Ich habe seitdem auf die Squish-Methode umgestellt, die bei Verwendung des Rails-Frameworks bei solchen Ereignissen intelligenter ist.

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

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

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

" Raheem Shaik ".strip

Es werden linke und rechte Seitenräume entfernt. Dieser Code würde uns geben:"Raheem Shaik"

Vergessen Sie auch nicht:

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

split.join wird alle Leerzeichen irgendwo in der Zeichenfolge sprengen.

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

Es ist einfach zu tippen und sich zu erinnern, daher ist es schön auf der Konsole und für schnelles Hacken. In seriösem Code wohl nicht willkommen, da er die Absicht maskiert.

(Basierend auf Piotrs Kommentar in Justicles Antwort oben.)

Sie könnten dies versuchen

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

using : space: Entfernt nicht unterbrechendes Leerzeichen zusammen mit dem regulären Leerzeichen.

Verwenden Sie gsub oder löschen Sie. Der Unterschied ist, dass gsub Tabs entfernen kann, während Löschen dies nicht kann. Manchmal haben Sie Registerkarten in Dateien, die von den Editoren hinzugefügt werden.

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"

Es gibt viele Möglichkeiten:
Leerzeichen von beiden Seiten entfernen:

Ein bisschen wie PHPs Trim ()

Foo_bar.strip

So entfernen Sie alle Leerzeichen:

Foo_bar.gsub(/ /, "")

So entfernen Sie alle Leerzeichen:

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

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

Die gsub-Methode reicht völlig aus.
Die gsub-Methode kann für eine Zeichenfolge aufgerufen werden und lautet:

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

Die gsub-Methode sucht nach jedem Vorkommen des ersten Arguments und ersetzt es durch das zweite Argument. In diesem Fall wird jedes Leerzeichen in der Zeichenfolge ersetzt und entfernt.

Ein anderes Beispiel:

b = "the white fox has a torn tail"

Ersetzen wir jedes Vorkommen des Buchstabens "t" durch ein Großbuchstaben "T".

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

Für ein Verhalten, das genau mit PHP übereinstimmt trim, ist die einfachste Methode, die String#stripMethode wie folgt zu verwenden :

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

Ruby hat auch eine Edit-in-Place-Version namens String.strip!(beachten Sie das nachfolgende '!'). Dies erfordert keine Erstellung einer Kopie der Zeichenfolge und kann für einige Verwendungszwecke erheblich schneller sein:

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

Beide Versionen erzeugen diese Ausgabe:

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

Ich habe einen Benchmark erstellt, um die Leistung einiger grundlegender Anwendungen von stripund strip!sowie einiger Alternativen zu testen . Der Test ist folgender:

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

Dies sind die Ergebnisse:

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)

Meine persönliche Präferenz ist die Verwendung der Methode .tr

wie in:

string = "this is a string to smash together"

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

Vielen Dank an @FrankScmitt für den Hinweis, dass Sie zum Löschen aller Leerzeichen (nicht nur Leerzeichen) Folgendes schreiben müssen:

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

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

Ich habe versucht, dies zu tun, da ich einen Datensatz- "Titel" als ID in der Ansicht verwenden wollte, aber die Titel Leerzeichen hatten.

Eine Lösung ist:

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

Rubys .scan()und .join()String-Methoden können auch dazu beitragen, Leerzeichen in Strings zu überwinden.

scan(/\w+/).join entfernt alle Leerzeichen und verbindet die Zeichenfolge

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

Außerdem wird Leerzeichen vom linken und rechten Teil der Zeichenfolge entfernt. Mittel ltrim, rtrimund trim. Nur für den Fall, dass jemand Hintergrundinformationen Chat FoxProoder Visual Basiceinspringt 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 >

Ich würde so etwas verwenden:

my_string = "Foo bar\nbaz quux"

my_string.split.join
=> "Foobarbazquux"

Ich bin etwas spät dran, aber ich entferne nachfolgende und führende Leerzeichen mit strip!. Wenn Sie ein Array haben, wie ich es getan habe, musste ich das Array durchlaufen und es nach dem Ende der Instanz speichern. Das ! hat sich darum gekümmert. Dadurch wurden alle Leerzeichen am Ende oder am Anfang entfernt, nicht nur das erste führende oder das letzte nachfolgende.

Zum Beispiel:

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

Dies würde ausgegeben werden zu: ["Hallo", "Melanie", "ist", "neu", "zu", "Programmierung"]. Ich habe dies in einem Video weiter untersucht / geteilt, das ich gemacht habe, um diesen Code für ähnliche Fragen hervorzuheben, die ich hatte .

Ich bin neu in der Programmierung und die Verwendung von Strip hat nicht funktioniert, da es nach dem Ende der Schleife nicht im Array gespeichert wurde.

Sie können dies versuchen:

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

um dies zu bekommen:

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

oder wenn Sie eine einzelne Zeichenfolge möchten, verwenden Sie einfach:

"ab c d efg hi ".split.join