introduction
Ruby strings ont de nombreuses méthodes intégrées qui facilitent la modification et la manipulation de texte, tâche commune dans de nombreux programmes.
Dans ce didacticiel, vous utiliserez des méthodes de chaîne pour déterminer la longueur d’une chaîne, des chaînes d’index et de scission, afin d’extraire des sous-chaînes, d’ajouter et de supprimer des espaces et d’autres caractères, de modifier la casse des caractères dans les chaînes et de rechercher et remplacer du texte. Lorsque vous aurez terminé, vous pourrez incorporer ces méthodes dans vos propres programmes.
Détermination de la longueur de la chaîne
La méthode de chaîne + longueur renvoie le nombre de caractères d’une chaîne. Cette méthode est utile lorsque vous devez imposer des longueurs de mot de passe minimales ou maximales ou tronquer des chaînes plus volumineuses afin qu’elles ne dépassent pas certaines limites et que vous puissiez les utiliser comme abréviations.
Voici un exemple qui affiche la longueur d’une phrase:
open_source = "Sammy contributes to open source."
print open_source.lengthOutput33N’oubliez pas que chaque caractère, y compris les lettres, les chiffres, les espaces et les symboles, sera compté puisqu’il fait partie de la chaîne.
Pour vérifier si une chaîne est vide, vous pouvez vérifier si sa longueur est + 0 +, ou vous pouvez utiliser la méthode + empty? +:
name = ""
name.empty? # true
name = "Sammy"
name.empty? # false
name = " "
name.empty? # falseVoyons comment indexer les chaînes et accéder au contenu d’une chaîne.
Accéder aux caractères d’une chaîne
Pour imprimer ou utiliser certains des caractères d’une chaîne, utilisez la méthode + slice + pour obtenir la partie qui vous convient.
Comme arrays, où chaque élément correspond à un numéro d’index, chaque caractère d’une chaîne correspond également à un numéro d’index, commençant par le numéro d’index 0.
Pour la chaîne + Sammy +, la répartition de l’index se présente comme suit:
| 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
S |
a |
m |
m |
y |
La méthode + slice + vous permet de saisir un seul caractère ou une plage de caractères. Passer un seul entier renvoie le caractère à cet index. Passer deux entiers, séparés par une virgule, indique + slice + pour renvoyer tous les caractères du premier index au dernier index, inclus. La méthode + slice + accepte également une plage, telle que + 1..4 +, pour spécifier les caractères à extraire:
"Sammy".slice(0) # "s"
"Sammy".slice(1,2) # "am"
"Sammy".slice(1..4) # "ammy"La syntaxe + [] + est un alias pour + slice +, vous pouvez donc traiter les chaînes comme des tableaux:
"Sammy"[0] # "s"
"Sammy"[1,2] # "am"
"Sammy"[1..4] # "ammy"Vous pouvez également accéder à un seul caractère à partir de la fin de la chaîne avec un index négatif. + -1 + vous permet d’accéder au dernier caractère de la chaîne, + -2 + accède à l’avant-dernier, et ainsi de suite.
Enfin, vous pouvez convertir la chaîne en un tableau de caractères avec la méthode + chars +:
"sammy".chars # ["S", "a", "m", "m", "y"]Cela peut être utile pour manipuler ou transformer les caractères de la chaîne.
Voyons ensuite comment modifier la casse des caractères d’une chaîne.
Conversion en majuscules et minuscules
Les méthodes + upcase + et` + downcase + `renvoient une chaîne contenant toutes les lettres d’une chaîne d’origine convertie en lettres majuscules ou minuscules. Les caractères de la chaîne qui ne sont pas des lettres ne seront pas modifiés.
Convertissons la chaîne + Sammy Shark + en majuscules:
name = "Sammy Shark"
print name.upcaseOuputSAMMY SHARKConvertissons maintenant la chaîne en minuscules:
print name.downcaseOuputsammy sharkLes fonctions + upcase + et + downcase + facilitent l’évaluation et la comparaison de chaînes en rendant le cas cohérent. Par exemple, si vous demandez un nom d’utilisateur et que l’utilisateur le saisit avec une lettre majuscule, vous pouvez mettre en minuscule l’entrée de l’utilisateur et la comparer à une valeur minuscule connue.
Les chaînes Ruby ont également une méthode + capitalize + qui retourne une nouvelle chaîne avec le premier caractère en majuscule:
"sammy".capitalize # "Sammy"C’est une méthode pratique, mais faites attention à votre utilisation. il ne met que la première lettre en majuscule et ne correspond donc pas toujours au cas d’utilisation dont vous avez besoin.
Ruby fournit également une méthode + swapcase + qui renvoie une chaîne avec le boîtier échangé:
text = "Sammy"
print text.swapcasesAMMYLes méthodes + downcase +, '+ upcase + ,' + captalize + et + swapcase + renvoient toutes une nouvelle chaîne et laissent la chaîne existante inchangée. Il est important de se rappeler si vous faites autre chose que d’imprimer immédiatement le texte. Regardez l’exemple suivant:
text = "sammy"
text.capitalize
print "Hello, #{text}!"OutputHello, sammy!Même si nous avons appelé + capitalize + dans la variable + text +, nous n’avons jamais capturé la valeur renvoyée par + capitalize +. Nous aurions besoin de réécrire le programme comme ceci:
text = "sammy"
text = text.capitalize
print "Hello, #{text}!"OutputHello, Sammy!Vous pouvez utiliser + downcase! +, '+ Upcase! + ,' + Capitalize! + Et + swapcase! + Pour modifier la chaîne d’origine à la place:
text = "sammy"
text = text.capitalize
print "Hello, #{text}!"Attention cependant. La mutation de la chaîne d’origine présente des inconvénients. Ruby fournit les deux méthodes afin que vous puissiez choisir celle qui correspond à vos besoins.
Ajoutons maintenant et supprimons les espaces des chaînes.
Rembourrage et Stripping
Si vous écrivez un programme qui doit formater du texte, vous constaterez souvent que vous voudrez ajouter de l’espace devant, après ou autour d’une chaîne afin de l’aligner sur d’autres données. Et d’autres fois, vous voudrez peut-être supprimer les caractères inutiles du début ou de la fin de vos chaînes, comme des espaces supplémentaires ou des caractères spéciaux.
Pour entourer une chaîne d’espaces, utilisez la méthode + center +:
"Sammy",center(21) # " Sammy "Vous pouvez spécifier une chaîne comme second argument si vous souhaitez utiliser un caractère différent:
" [Sammy] ".center(21, "<>") # "<><><> [Sammy] <><><>"Les méthodes + ljust et` + rjust` ajoutent des espaces ou des caractères à gauche ou à droite d’une chaîne et fonctionnent exactement comme la méthode + center +:
"Sammy".ljust(20) # "Sammy "
"Sammy".rjust(20) # " Sammy"
"Sammy".rjust(20, "!") # "!!!!!!!!!!!!!!!Sammy"Pour supprimer les espaces de début d’une chaîne, utilisez la méthode + rstrip +. Pour supprimer les espaces de fin, utilisez + lstrip +. Utilisez + strip + pour supprimer les espaces de début et de fin:
" Sammy".rstrip # "Sammy"
"Sammy ".lstrip # "Sammy"
" Sammy ".strip # "Sammy"Vous pouvez utiliser les méthodes + center! +, + Ljust + !, + rjust! +, + Lstrip! +, + Rstrip! + Et + strip! + Pour modifier l’original chaîne.
Parfois, vous devrez supprimer des caractères à la fin d’une chaîne. La méthode + chop + de Ruby fait justement cela; il supprime le dernier caractère d’une chaîne:
"Sammy".chop # "Samm"Ceci est particulièrement utile pour supprimer le caractère de nouvelle ligne (+ \ n +) des chaînes:
"This string has a newline\n".chopLa méthode + chop + laisse la chaîne d’origine intacte et renvoie une nouvelle chaîne. La méthode + chop! + Modifie la chaîne existante à la place.
La méthode + chomp + peut supprimer plusieurs caractères de la fin d’une chaîne:
"Sammy".chomp("my") # "Sam"Si vous ne spécifiez pas de chaîne à supprimer, + chomp + supprimera la nouvelle ligne:
"This string has a newline\n".chomp # "This string has a newlineCependant, si la chaîne ne contient pas de caractère de nouvelle ligne, + chomp + renvoie simplement la chaîne d’origine:
"Sammy".chomp # "Sammy"Cela rend + chomp + un peu plus sûr d’utiliser lors de la suppression de nouvelles lignes que la méthode + chop +, qui supprime toujours le dernier caractère.
Ruby a une méthode + chomp! + Qui mute la chaîne d’origine et retourne la chaîne modifiée si elle a été remplacée. Cependant, contrairement à + chomp +, la méthode + chomp! + Renvoie + nil + si elle n’a pas modifié la chaîne:
string = "Hello\n"
string.chomp! # "Hello"
string = "Hello"
string.chomp! # nilVoyons ensuite comment rechercher du texte dans des chaînes.
Recherche de caractères et de texte
Parfois, vous devez déterminer si une chaîne contient ou non une autre chaîne.
La méthode + include? + Vérifie si une chaîne en contient une autre. Il retourne + true si la chaîne existe et` + false` sinon:
"Sammy".include?("a") # true
"Sammy".include?("b") # falseLa méthode + index + renvoie l’index d’un caractère. Il peut également identifier l’index du premier caractère d’une sous-chaîne. Et il retourne + nil + si le caractère ou la sous-chaîne n’existe pas:
"Sammy".index("a") # 1
"Sammy".index("mm") # 2
"Sammy".index("Fish") # nilLa méthode + index ne trouve cependant que la première occurrence. Voici un exemple avec une chaîne plus longue:
text = "Sammy has a balloon"
text.index("a") # 1La chaîne + Sammy a un ballon a quatre occurrences de la lettre« a ». Mais + index + n’a trouvé que la première occurrence. Vous devrez écrire quelque chose de plus spécifique pour localiser l’une des autres occurrences.
Par exemple, vous pouvez convertir la chaîne en un tableau de caractères et utiliser les méthodes array pour parcourir le résultats et sélectionnez les index pour le personnage. Voici une méthode pour le faire:
text = "Sammy has a balloon"
indices = text.chars
.each_with_index
.select{|char, index| char == "a" }
.map{|pair| pair.last}
print indices[1, 7, 10, 13]+ each_with_index + renvoie un tableau à deux dimensions contenant une entrée pour chaque caractère et son index. + select + le réduit aux entrées où le caractère est + a +, et + map + convertit le tableau à deux dimensions en un tableau à une dimension des indices.
En plus de rechercher des caractères dans une chaîne, vous pouvez vérifier si une chaîne commence par un caractère ou une sous-chaîne à l’aide de la méthode + start_with? +:
text = "Sammy has a balloon"
text.start_with?("s") # true
text.start_with?("Sammy has" # trueLa méthode + start_with? + Accepte plusieurs chaînes et renvoie true si l’une d’elles correspond:
text = "Sammy has a balloon"
text.start_with?("Sammy the Shark", "Sammy") # trueDans cet exemple, «Sammy the Shark» n’est pas trouvé, mais «Sammy» l’est; la valeur de retour est donc + true +.
Vous pouvez utiliser la méthode + end_with? + Pour voir si une chaîne se termine par la sous-chaîne donnée. Cela fonctionne exactement comme + start_with? +:
text = "Sammy has a balloon"
text.end_with?("balloon") # true
text.end_with?("boomerang") # false
text.end_with?("boomerang", "balloon") # trueNous avons cherché des moyens de trouver du texte. Voyons donc comment remplacer ce texte par un texte différent.
Remplacement de texte dans des chaînes
La fonctionnalité de recherche et de remplacement dans les traitements de texte vous permet de rechercher une chaîne et de la remplacer par une autre chaîne. Vous pouvez le faire en Ruby avec les méthodes + sub + et + gsub + `.
La méthode + sub + remplace une partie d’une chaîne par une autre.
Sammy n’a plus le ballon; il s’est envolé. Changeons la sous-chaîne " has "+" en `+" had ".
balloon = "Sammy has a balloon"
print balloon.sub("has","had")Notre sortie ressemblera à ceci:
OuputSammy had a balloon.La méthode + sub ne remplace que la première occurrence de la correspondance par le nouveau texte. Utilisons une chaîne modifiée qui a deux occurrences du mot + has +:
balloon = "Sammy has a balloon. The balloon has a ribbon"
print balloon.sub("has","had")OutputSammy a balloon. The balloon has a ribbonSeule la première occurrence a changé.
Pour les changer tous, utilisez la méthode + gsub +, qui effectue la substitution global:
balloon = "Sammy has a balloon. The balloon has a ribbon"
print balloon.gsub("has","had")OutputSammy a balloon. The balloon a ribbonLes méthodes + sub + et + gsub + renvoient toujours les nouvelles chaînes, laissant les originaux non modifiés. Voyons cela en remplaçant «ballon» par «boomerang» dans notre chaîne:
text = "Sammy has a balloon"
text.gsub("ballooon", "boomerang")
print textOutputSammy has a balloonLa sortie ne montre pas le résultat recherché, car, bien que nous ayons spécifié la substitution, nous n’avons jamais affecté le résultat + gsub + à une nouvelle variable. Pour obtenir le résultat souhaité, nous pourrions réécrire le programme comme suit:
text = "Sammy has a balloon"
text = text.sub("ballooon", "boomerang")
print textAlternativement, vous pouvez utiliser + sub! + À la place, ce qui modifie la chaîne d’origine. Essayons cela en faisant quelques remplacements de corde. Nous allons changer «ballon rouge» en «boomerang bleu»:
text = "Sammy has a red balloon"
text.sub!("red", "blue")
text.sub!("balloon", "boomerang")
print textOutputSammy has a blue boomerangVous pouvez également utiliser la méthode + gsub! + Pour effectuer une substitution globale.
Les méthodes + sub + et + gsub + acceptent large pour le modèle de recherche. Remplaçons toutes les voyelles de la chaîne par le symbole + @ +:
"Sammy has a red balloon".gsub /[aeiou]/, "@""S@mmy h@s @ r@d b@ll@@n"La valeur de remplacement ne doit pas nécessairement être une chaîne. Vous pouvez utiliser un hachage pour spécifier comment remplacer des caractères ou des éléments individuels. Remplaçons toutes les occurrences de la lettre + a par` + @ + et tous les caractères + o + `avec des zéros:
"Sammy has a red balloon".gsub /[aeiou]/, {"a" => "@", "o" => "0"}
# "S@mmy h@s @ rd b@ll00n"Vous pouvez l’utiliser pour effectuer des substitutions plus complexes avec moins de code.
Conclusion
Dans ce tutoriel, vous avez manipulé et manipulé des chaînes à l’aide de certaines des méthodes intégrées pour le type de données string. Vous avez également appris que de nombreuses méthodes de travail avec les chaînes existent en deux variantes: l’une qui laisse la chaîne inchangée et l’autre qui modifie la chaîne d’origine. Lequel vous utilisez dépend de vos besoins. Ruby vous donne la possibilité de choisir comment vous voulez utiliser vos données. Cependant, écrire du code qui ne modifie pas les données existantes peut être plus facile à déboguer plus tard.
Veillez à consulter ces didacticiels connexes pour continuer à explorer comment utiliser les données dans Ruby: