Função Ruby para remover todos os espaços em branco?

Qual é a função Ruby para remover todos os espaços em branco? Estou procurando algo como o PHP trim()?

Se você deseja remover apenas os espaços em branco à esquerda e à direita (como o aparamento do PHP), você pode usar .strip, mas se quiser remover todo o espaço em branco, pode usar .gsub(/\s+/, "").

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

E para emular a trim()função do PHP :

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

Resposta relacionada:

"   clean up my edges    ".strip

retorna

"clean up my edges"

String#strip - remova todo o espaço em branco do início e do fim.

String#lstrip - desde o começo.

String#rstrip - só do fim.

String#chomp(sem argumentos) - exclui separadores de linha ( \nou \r\n) do final.

String#chop - exclui o último caractere.

String#delete- x.delete(" \t\r\n")- exclui todos os espaços em branco listados.

String#gsub- x.gsub(/[[:space:]]/, '')- remove todos os espaços em branco, incluindo os unicode .

Nota : Todos os métodos acima retornam uma nova sequência em vez de alterar o original. Se você deseja alterar a string no lugar, chame o método correspondente com !no final.

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

Excluir funciona mais 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)

Se você estiver usando o Rails / ActiveSupport , poderá usar o squishmétodo Remove o espaço em branco nas duas extremidades da cadeia e agrupa vários espaços em branco em um único espaço.

Por exemplo.

" a  b  c ".squish

resultará em:

"a b c"

Verifique esta referência em api.rubyonrails.org .

É um pouco tarde, mas qualquer pessoa pesquisando esta página no Google pode estar interessada nesta versão -

Se você deseja limpar um pedaço de texto pré-formatado que um usuário pode ter recortado e colado no seu aplicativo de alguma forma, mas preserva o espaçamento entre palavras, tente o seguinte:

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"

O .stripmétodo Ruby executa o PHP equivalente atrim() .

Para remover todo o espaço em branco:

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

A @Tass me informou que minha resposta original remove as cartas duplicadas sucessivamente - YUCK! Desde então, mudei para o método squish, que é mais inteligente sobre essas ocorrências se estiver usando a estrutura do Rails.

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

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

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

" Raheem Shaik ".strip

Ele remove os espaços do lado esquerdo e direito. Este código nos daria:"Raheem Shaik"

Também não se esqueça:

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

split.join irá explodir todos os espaços em qualquer lugar da string.

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

É fácil digitar e lembrar, por isso é bom no console e para hackers rápidos. Indiscutivelmente, não é bem-vindo em código sério, pois mascara a intenção.

(Com base no comentário de Piotr na resposta de Justicle acima.)

Você poderia tentar isso

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

using : space: remove o espaço sem quebra, juntamente com o espaço regular.

Use gsub ou delete. A diferença é que o gsub pode remover as guias, enquanto a exclusão não pode. Às vezes, você tem guias nos arquivos que são adicionados pelos editores.

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"

Existem várias maneiras:
Para remover espaços em branco de ambos os lados:

Mais ou menos como o php's trim ()

Foo_bar.strip

Para remover todos os espaços:

Foo_bar.gsub(/ /, "")

Para remover todo o espaço em branco:

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

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

O método gsub funcionará perfeitamente.
O método gsub pode ser chamado em uma string e diz:

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

O método gsub procura todas as ocorrências do primeiro argumento e o substitui pelo segundo argumento. Nesse caso, ele substituirá todos os espaços da string e os removerá.

Outro exemplo:

b = "the white fox has a torn tail"

Vamos substituir todas as ocorrências da letra "t" por uma maiúscula "T"

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

Para um comportamento exatamente igual ao PHP trim, o método mais simples é usar o String#stripmétodo, da seguinte maneira:

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

O Ruby também possui uma versão edit-in-place, chamada String.strip!(observe o final '!'). Isso não requer a criação de uma cópia da sequência e pode ser significativamente mais rápido para alguns usos:

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

Ambas as versões produzem esta saída:

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

Criei um benchmark para testar o desempenho de alguns usos básicos de stripe strip!, assim como algumas alternativas. O teste é este:

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

Estes são os 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)

Minha preferência pessoal é usar o método .tr

como em:

string = "this is a string to smash together"

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

Obrigado a @FrankScmitt por apontar que, para fazer isso excluir todos os espaços em branco (não apenas os espaços), você precisará escrevê-lo da seguinte forma:

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

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

Eu estava tentando fazer isso porque queria usar um "título" de registros como um ID na exibição, mas os títulos tinham espaços.

uma solução é:

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

Ruby .scan()e.join() métodos de String também podem ajudar a superar o espaço em branco na string.

scan(/\w+/).join removerá todos os espaços e unirá a string

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

Também está removendo espaço da parte esquerda e direita da string. Meios ltrim, rtrime trim. Apenas no caso, se alguém tem fundo longo C, FoxProou Visual Basice saltar em 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 >

Eu usaria algo como isto:

my_string = "Foo bar\nbaz quux"

my_string.split.join
=> "Foobarbazquux"

Estou um pouco atrasado para o jogo, mas removo os espaços em branco à direita e à esquerda usando strip! . Se você tem uma matriz, como eu, precisei percorrer a matriz e salvá-la após o término da instância. O ! cuidou disso. Isso removeu todos os espaços em branco no final ou no início, não apenas o primeiro à esquerda ou o último à direita.

Por exemplo:

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

Isso produziria para: ["olá", "Melanie", "é", "novo", "para", "programação"]. Eu explorei / compartilhei isso em um vídeo que fiz para destacar esse código para uma pergunta semelhante que eu tinha .

Eu sou mais novo na programação e o uso de strip não funcionou, pois não o salvou na matriz após o término do loop.

Você pode tentar isso:

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

para conseguir isso:

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

ou se você quiser uma única string, use:

"ab c d efg hi ".split.join