Ruby function to remove all white spaces?

If you want to remove only leading and trailing whitespace (like PHP's trim) you can use .strip, but if you want to remove all whitespace, you can use .gsub(/\s+/, "") instead .

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

And to emulate PHP's trim() function:

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

String#strip - remove all whitespace from the start and the end.

String#lstrip - just from the start.

String#rstrip - just from the end.

String#chomp (with no arguments) - deletes line separators (\n or \r\n) from the end.

String#chop - deletes the last character.

String#delete - x.delete(" \t\r\n") - deletes all listed whitespace.

String#gsub - x.gsub(/[[:space:]]/, '') - removes all whitespace, including unicode ones.

Note: All the methods above return a new string instead of mutating the original. If you want to change the string in place, call the corresponding method with ! at the end.

Related answer:

"   clean up my edges    ".strip

returns

"clean up my edges"

If you are using Rails/ActiveSupport, you can use squish method. It removes white space on both ends of the string and groups multiple white space to single space.

For eg.

" a  b  c ".squish

will result to:

"a b c"

Check this reference from api.rubyonrails.org.

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

Delete works faster =)

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)

Ruby's .strip method performs the PHP equivalent to trim().

To remove all whitespace:

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

@Tass made me aware that my original answer removes duplicate letters in succession - YUCK! I've since switched to the squish method which is smarter about such occurrences if using the Rails framework.

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

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

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

It's a bit late, but anyone else googling this page might be interested in this version -

If you want to clean up a chunk of pre-formatted text that a user may have cut & pasted into your app somehow, but preserve the word spacing, try this:

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"

To remove whitespace on both sides:

Kind of like php's trim()

"   Hello  ".strip

To remove all spaces:

"   He    llo  ".gsub(/ /, "")

To remove all whitespace:

"   He\tllo  ".gsub(/\s/, "")

" Raheem Shaik ".strip

It will removes left & right side spaces. This code would give us: "Raheem Shaik"

split.join will blast all spaces anywhere in the string.

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

It's easy to type and remember, so it's nice on the console and for quick hacking. Arguably not welcome in serious code though as it masks the intent.

(Based on Piotr's comment in Justicle's answer above.)

Also don't forget:

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

You Could try this

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

using :space: removes non breaking space along with regular space.

Use gsub or delete. The difference is gsub could remove tabs, while delete cannot. Sometimes you do have tabs in files which are added by the editors.

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"

The gsub method will do just fine. The gsub method can be called on a string and says:

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

The gsub method searches for every occurrence of the first argument and replaces it with the second argument. In this case, it will replace every space within the string and remove it.

Another example:

b = "the white fox has a torn tail"

Let's replace every occurrence of the letter " t " with a capital " T "

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

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

For behavior exactly matching PHP trim, the simplest method is to use the String#strip method, like so:

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

Ruby also has an edit-in-place version, as well, called String.strip! (note the trailing '!'). This doesn't require creating a copy of the string, and can be significantly faster for some uses:

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

Both versions produce this output:

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

I created a benchmark to test the performance of some basic uses of strip and strip!, as well as some alternatives. The test is this:

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

These are the results:

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)

A lot of suggestions work here, but when I read your question and the specific line saying "removing all the whitespace", what came to my mind was this:

" a b c " => "abc"

And if that is really what is required, you can do this simple operation

wide_string = " a b c "

narrow_string = wide_string.delete(" ")

# you can pass all the different kinds 
# of whitespaces that you want to remove

puts narrow_string # => "abc"

My personal preference is using the method .tr

as in:

string = "this is a string to smash together"

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

Thanks to @FrankScmitt for pointing out that to make this delete all whitespace(not just spaces) you would need to write it as such:

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

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

I was trying to do this as I wanted to use a records "title" as an id in the view but the titles had spaces.

a solution is:

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

I'm a bit late to the game, but I remove trailing and leading whitespaces by using strip!. If you have an array, such as I did, I needed to iterate through the array and save it after the instance ended. The ! took care of this. This removed all whitespaces at the end or the beginning, not just the first leading or the last trailing.

For example:

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

This would output to: ["hello","Melanie", "is", "new ", "to", "programming"]. I further explored/shared this in a video I made to highlight this code for similar question I had.

I'm newer to programming and using strip did not work as it didn't save it to the array after the loop ended.

I would use something like this:

my_string = "Foo bar\nbaz quux"

my_string.split.join
=> "Foobarbazquux"

Ruby's .scan() and .join() methods of String can also help to overcome whitespace in string.

scan(/\w+/).join will remove all spaces and join the string

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

It is also removing space from left and right part of the string. Means ltrim, rtrim and trim. Just in case if someone has background over C, FoxPro or Visual Basic and jump in 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 >

You can try this:

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

in order to get this:

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

or if you want a single string, just use:

"ab c d efg hi ".split.join