Ruby fonction pour supprimer tous les espaces blancs?
Quelle est la fonction Ruby à supprimer tous espace? Un peu comme php's trim()?
Si vous voulez supprimer uniquement les espaces de début et de fin (comme le trim), vous pouvez utiliser .strip, mais si vous souhaitez supprimer all espaces, vous pouvez utiliser .gsub(/\s+/, "") à la place.
s = "I have white space".delete(' ')
Et pour émuler la fonction trim() de PHP:
s = " I have leading and trailing white space ".strip
Réponse connexe:
" clean up my edges ".strip
résultats
"clean up my edges"
String#strip - supprime tous les espaces du début et de la fin.
String#lstrip - juste du début.
String#rstrip - juste à la fin.
String#chomp (sans argument) - supprime les séparateurs de ligne (_\n_ ou _\r\n_) de la fin.
String#chop - supprime le dernier caractère.
String#delete - x.delete(" \t\r\n") - supprime tous les espaces énumérés.
String#gsub - x.gsub(/[[:space:]]/, '') - supprime tous les espaces, y compris caractères 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 vite =)
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)
Vous pouvez utiliser la méthode squish. Il supprime les espaces aux deux extrémités de la chaîne et regroupe plusieurs espaces en un seul espace.
Pour par exemple.
" a b c ".squish
résultera à:
"a b c"
Vérifiez cette référence de api.rubyonrails.org .
EDIT: Cela ne fonctionne que pour Ruby sur Rails
Il est un peu tard, mais toute autre personne cherchant dans cette page pourrait être intéressée par cette version -
Si vous souhaitez nettoyer un bloc de texte préformaté qu'un utilisateur a peut-être coupé et collé dans votre application, tout en préservant 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 méthode .strip de Ruby exécute le PHP équivalent à trim().
Pour supprimer tous les espaces:
" leading trailing ".squeeze(' ').strip
=> "leading trailing"
@Tass m'a fait savoir que ma réponse originale supprimait successivement les lettres en double - YUCK! Depuis, je suis passé à la méthode squish qui est plus intelligente à propos de telles occurrences si vous utilisez le framework Rails.
require 'active_support/all'
" leading trailing ".squish
=> "leading trailing"
" good men ".squish
=> "good men"
" Raheem Shaik ".strip
Cela supprimera 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 fera sauter tous les espaces n'importe où dans la chaîne.
" a b c d ".split.join
> "abcd"
Il est facile de taper et de se souvenir, alors c'est agréable sur la console et pour le piratage rapide. On peut soutenir que ce n’est pas le bienvenu dans un code sérieux, car il masque l’intention.
(Basé sur le commentaire de Piotr dans réponse de Justicle ci-dessus.)
Tu pourrais essayer ça
"Some Special Text Values".gsub(/[[:space:]]+/, "")
using : space: supprime l'espace insécable avec l'espace normal.
Utilisez gsub ou delete. La différence est que gsub peut supprimer des onglets, alors que supprimer ne le peut pas. Parfois, vous avez des onglets dans les 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"
"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 que le comportement corresponde exactement à PHP trim, la méthode la plus simple consiste à utiliser la méthode String#strip, comme suit:
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 de montage sur place, également appelée String.strip! (notez le "!" Final.). Cela ne nécessite pas de créer une copie de la chaîne et peut être considérablement 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 strip et strip!, ainsi que de quelques 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
Ce sont 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)
J'essayais de faire cela car je voulais utiliser un "titre" d'enregistrements comme identifiant dans la vue, mais les titres avaient des espaces.
une solution est:
record.value.delete(' ') # Foo Bar -> FooBar
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 pour nous avoir signalé que pour faire cette suppression tous espaces (et pas seulement les espaces), vous devez l'écrire en tant que tel:
string = "this is a string with tabs\t and a \nnewline"
string.tr(" \n\t", '') # => "thisisastringwithtabsandanewline"
Je voudrais utiliser quelque chose comme ça:
my_string = "Foo bar\nbaz quux"
my_string.split.join
=> "Foobarbazquux"
Les méthodes .scan() et .join() de String de String peuvent également aider à surmonter les espaces dans la chaîne.
scan(/\w+/).join supprimera tous les espaces et joindra 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. Signifie ltrim, rtrim et trim. Juste au cas où quelqu'un aurait un arrière-plan sur C, FoxPro ou Visual Basic et sauter dans 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 >