Fonction Ruby pour supprimer tous les espaces blancs?

Quelle est la fonction Ruby pour supprimer tous les espaces blancs? Je cherche quelque chose comme PHP trim()?

Si vous souhaitez supprimer uniquement les espaces de début et de fin (comme le découpage de PHP), vous pouvez utiliser .strip, mais si vous souhaitez supprimer tous les espaces, vous pouvez utiliser à la.gsub(/\s+/, "")place.

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

Et pour émuler la trim()fonction de PHP :

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

Réponse connexe:

"   clean up my edges    ".strip

Retour

"clean up my edges"

String#strip - supprimer tous les espaces blancs du début et de la fin.

String#lstrip - dès le début.

String#rstrip - juste de la fin.

String#chomp(sans argument) - supprime les séparateurs de ligne ( \nou \r\n) de la fin.

String#chop - supprime le dernier caractère.

String#delete- x.delete(" \t\r\n")- supprime tous les espaces listés.

String#gsub- x.gsub(/[[:space:]]/, '')- supprime tous les espaces, y compris les espaces unicode .

Remarque : Toutes les méthodes ci-dessus renvoient une nouvelle chaîne au lieu de muter l'original. Si vous souhaitez modifier la chaîne en place, appelez la méthode correspondante avec !à la fin.

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

Supprimer fonctionne plus rapidement =)

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 vous utilisez Rails / ActiveSupport , vous pouvez utiliser la squishméthode. Il supprime les espaces blancs aux deux extrémités de la chaîne et regroupe plusieurs espaces blancs en un seul espace.

Par exemple.

" a  b  c ".squish

résultera en:

"a b c"

Vérifiez cette référence sur api.rubyonrails.org .

Il est un peu tard, mais quiconque googler cette page pourrait être intéressé par cette version -

Si vous souhaitez nettoyer un morceau de texte pré-formaté qu'un utilisateur a peut-être coupé et collé dans votre application, mais conservez l'espacement des mots, essayez ceci:

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"

La .stripméthode de Ruby effectue l'équivalent PHP detrim() .

Pour supprimer tous les espaces:

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

@Tass m'a fait savoir que ma réponse originale supprime les lettres en double successivement - YUCK! Depuis, je suis passé à la méthode squish qui est plus intelligente sur de telles occurrences si vous utilisez le framework Rails.

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

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

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

" Raheem Shaik ".strip

Il supprime les espaces latéraux gauche et droit. Ce code nous donnerait:"Raheem Shaik"

N'oubliez pas non plus:

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

split.join explosera tous les espaces n'importe où dans la chaîne.

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

Il est facile à taper et à mémoriser, il est donc agréable sur la console et pour un piratage rapide. Sans doute pas la bienvenue dans un code sérieux, car cela masque l'intention.

(D'après le commentaire de Piotr dans la réponse de Justicle ci-dessus.)

Vous pourriez essayer ceci

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

using : space: supprime l'espace insécable avec l'espace régulier.

Utilisez gsub ou delete. La différence est que gsub pourrait supprimer des onglets, contrairement à la suppression. Parfois, vous avez des onglets dans des fichiers qui sont ajoutés par les éditeurs.

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"

Il existe plusieurs façons:
Pour supprimer les espaces des deux côtés:

Un peu comme le trim de php ()

Foo_bar.strip

Pour supprimer tous les espaces:

Foo_bar.gsub(/ /, "")

Pour supprimer tous les espaces:

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

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

La méthode gsub fera très bien l'affaire.
La méthode gsub peut être appelée sur une chaîne et dit:

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

La méthode gsub recherche chaque occurrence du premier argument et la remplace par le deuxième argument. Dans ce cas, il remplacera chaque espace de la chaîne et le supprimera.

Un autre exemple:

b = "the white fox has a torn tail"

Remplaçons chaque occurrence de la lettre "t" par un "T" majuscule

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

Pour un comportement correspondant exactement à PHP trim, la méthode la plus simple consiste à utiliser la String#stripméthode, comme ceci:

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

Ruby a également une version d'édition sur place, appelée String.strip!(notez le "!"). Cela ne nécessite pas de créer une copie de la chaîne et peut être beaucoup plus rapide pour certaines utilisations:

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

Les deux versions produisent cette sortie:

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

J'ai créé une référence pour tester les performances de certaines utilisations de base de stripet strip!, ainsi que de certaines alternatives. Le test est le suivant:

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

Voici les résultats:

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)

Ma préférence personnelle utilise la méthode .tr

un péché:

string = "this is a string to smash together"

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

Merci à @FrankScmitt d'avoir souligné que pour que cela supprime tous les espaces (pas seulement les espaces), vous devez l'écrire comme tel:

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

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

J'essayais de le faire car je voulais utiliser un "titre" de disques comme identifiant dans la vue mais les titres avaient des espaces.

une solution est:

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

Ruby .scan()et les .join()méthodes de String peuvent également aider à surmonter les espaces blancs dans String.

scan(/\w+/).join supprimera tous les espaces et rejoindra la chaîne

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

Il supprime également l'espace des parties gauche et droite de la chaîne. Moyens ltrim, rtrimet trim. Juste au cas où quelqu'un a des antécédents C, FoxProou Visual Basicet sauter 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 >

J'utiliserais quelque chose comme ça:

my_string = "Foo bar\nbaz quux"

my_string.split.join
=> "Foobarbazquux"

Je suis un peu en retard dans le jeu, mais je supprime les espaces de fin et de début en utilisant strip! . Si vous avez un tableau, comme je l'ai fait, je devais parcourir le tableau et l'enregistrer une fois l'instance terminée. Le ! a pris soin de cela. Cela supprimait tous les espaces à la fin ou au début, pas seulement le premier début ou le dernier arrière.

Par exemple:

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

Cela produirait à: ["bonjour", "Mélanie", "est", "nouveau", "à", "programmation"]. J'ai encore exploré / partagé cela dans une vidéo que j'ai faite pour mettre en évidence ce code pour une question similaire que j'avais .

Je suis plus récent dans la programmation et l'utilisation de strip n'a pas fonctionné car il ne l'a pas enregistré dans le tableau une fois la boucle terminée.

Vous pouvez essayer ceci:

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

afin d'obtenir ceci:

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

ou si vous voulez une seule chaîne, utilisez simplement:

"ab c d efg hi ".split.join