a

ASCII (identique à aucun). C'est la valeur par défaut.

e

EUC.

n

Aucun (identique à ASCII).

u

UTF-8.

str % arg

Formate une chaîne à l'aide d'une spécification de format. arg doit être un tableau s'il contient plus d'une substitution. Pour plus d'informations sur la spécification de format, consultez sprintf sous «Module noyau».

str * integer

Renvoie une nouvelle chaîne contenant le nombre entier multiplié par str. En d'autres termes, str est un nombre entier répété.

str + other_str

Concatène other_str à str.

str << obj

Concatène un objet en str. Si l'objet est un Fixnum compris entre 0,255, il est converti en caractère. Comparez-le avec concat.

str <=> other_str

Compare str avec other_str, renvoyant -1 (inférieur à), 0 (égal) ou 1 (supérieur à). La comparaison est sensible à la casse.

str == obj

Teste l'égalité de str et obj. Si obj n'est pas une chaîne, renvoie false; renvoie vrai si str <=> obj renvoie 0.

str =~ obj

Correspond à str avec un modèle d'expression régulière obj. Renvoie la position où le match commence; sinon, faux.

str.capitalize

Met une chaîne en majuscule.

str.capitalize!

Identique à capitaliser, mais les modifications sont apportées en place.

str.casecmp

Effectue une comparaison insensible à la casse des chaînes.

str.center

Centre une chaîne.

str.chomp

Supprime le séparateur d'enregistrement ($ /), généralement \ n, de la fin d'une chaîne. Si aucun séparateur d'enregistrement n'existe, ne fait rien.

str.chomp!

Identique à chomp, mais les modifications sont apportées.

str.chop

Supprime le dernier caractère de str.

str.chop!

Identique à chop, mais les modifications sont apportées en place.

str.concat(other_str)

Concatène other_str à str.

str.count(str, ...)

Compte un ou plusieurs jeux de caractères. S'il y a plus d'un jeu de caractères, compte l'intersection de ces jeux

str.crypt(other_str)

Applique un hachage cryptographique unidirectionnel à str. L'argument est la chaîne salt, qui doit comporter deux caractères, chaque caractère dans la plage az, AZ, 0.9,. ou /.

str.delete(other_str, ...)

Renvoie une copie de str avec tous les caractères à l'intersection de ses arguments supprimés.

str.delete!(other_str, ...)

Identique à la suppression, mais les modifications sont effectuées sur place.

str.downcase

Renvoie une copie de str avec toutes les lettres majuscules remplacées par des minuscules.

str.downcase!

Identique au downcase, mais des modifications sont apportées.

str.dump

Renvoie une version de str avec tous les caractères non imprimables remplacés par la notation \ nnn et tous les caractères spéciaux échappés.

str.each(separator = $/) { |substr| block }

Divise str en utilisant l'argument comme séparateur d'enregistrement ($ / par défaut), en passant chaque sous-chaîne au bloc fourni.

str.each_byte { |fixnum| block }

Passe chaque octet de str au bloc, renvoyant chaque octet sous forme de représentation décimale de l'octet.

str.each_line(separator=$/) { |substr| block }

Divise str en utilisant l'argument comme séparateur d'enregistrement ($ / par défaut), en passant chaque sous-chaîne au bloc fourni.

str.empty?

Renvoie true si str est vide (a une longueur nulle).

str.eql?(other)

Deux chaînes sont égales si elles ont la même longueur et le même contenu.

str.gsub(pattern, replacement) [or]

str.gsub(pattern) { |match| block }

Renvoie une copie de str avec toutes les occurrences de pattern remplacées par le remplacement ou la valeur du bloc. Le modèle sera généralement une expression rationnelle; s'il s'agit d'une chaîne, aucun métacaractère d'expression régulière ne sera interprété (c'est-à-dire que / \ d / correspondra à un chiffre, mais '\ d' correspondra à une barre oblique inverse suivie d'un 'd')

str[fixnum] [or] str[fixnum,fixnum] [or] str[range] [or] str[regexp] [or] str[regexp, fixnum] [or] str[other_str]

Références str, en utilisant les arguments suivants: one Fixnum, renvoie un code de caractère au fixnum; deux Fixnums, retourne une sous-chaîne commençant à un offset (premier fixnum) à length (second fixnum); range, retourne une sous-chaîne dans la plage; regexp renvoie une partie de la chaîne correspondante; regexp avec fixnum, retourne les données correspondantes au fixnum; other_str renvoie la sous-chaîne correspondant à other_str. Un Fixnum négatif commence à la fin de la chaîne avec -1.

str[fixnum] = fixnum [or] str[fixnum] = new_str [or] str[fixnum, fixnum] = new_str [or] str[range] = aString [or] str[regexp] = new_str [or] str[regexp, fixnum] = new_str [or] str[other_str] = new_str ]

Remplacez (attribuez) tout ou partie d'une chaîne. Synonyme de slice !.

str.gsub!(pattern, replacement) [or] str.gsub!(pattern) { |match|block }

Effectue les substitutions de String # gsub en place, en retournant str ou nil si aucune substitution n'a été effectuée.

str.hash

Renvoie un hachage basé sur la longueur et le contenu de la chaîne.

str.hex

Traite les caractères de début de str comme une chaîne de chiffres hexadécimaux (avec un signe facultatif et un 0x facultatif) et renvoie le nombre correspondant. Zéro est renvoyé en cas d'erreur.

str.include? other_str [or] str.include? fixnum

Renvoie true si str contient la chaîne ou le caractère donné.

str.index(substring [, offset]) [or]

str.index(fixnum [, offset]) [or]

str.index(regexp [, offset])

Renvoie l'index de la première occurrence de la sous-chaîne, du caractère (fixnum) ou du motif (regexp) donné dans str. Renvoie nil si non trouvé. Si le deuxième paramètre est présent, il spécifie la position dans la chaîne pour commencer la recherche.

str.insert(index, other_str)

Insère other_str avant le caractère à l'index donné, en modifiant str. Les indices négatifs comptent à partir de la fin de la chaîne et s'insèrent après le caractère donné. L'intention est d'insérer une chaîne pour qu'elle commence à l'index donné.

str.inspect

Renvoie une version imprimable de str, avec échappements de caractères spéciaux.

str.intern [or] str.to_sym

Renvoie le symbole correspondant à str, créant le symbole s'il n'existait pas auparavant.

str.length

Renvoie la longueur de str. Comparez la taille.

str.ljust(integer, padstr = ' ')

Si integer est supérieur à la longueur de str, renvoie une nouvelle chaîne de longueur integer avec str justifiée à gauche et complétée avec padstr; sinon, retourne str.

str.lstrip

Renvoie une copie de str avec les espaces au début supprimés.

str.lstrip!

Supprime les espaces de début de str, retournant nil si aucune modification n'a été apportée.

str.match(pattern)

Convertit le motif en une expression rationnelle (si ce n'est déjà fait), puis invoque sa méthode de correspondance sur str.

str.oct

Traite les premiers caractères de str comme une chaîne de chiffres octaux (avec un signe facultatif) et renvoie le nombre correspondant. Renvoie 0 si la conversion échoue.

str.replace(other_str)

Remplace le contenu et la souillure de str par les valeurs correspondantes dans other_str.

str.reverse

Renvoie une nouvelle chaîne avec les caractères de str dans l'ordre inverse.

str.reverse!

Inverse str en place.

str.rindex(substring [, fixnum]) [or]

str.rindex(fixnum [, fixnum]) [or]

str.rindex(regexp [, fixnum])

Renvoie l'index de la dernière occurrence de la sous-chaîne, du caractère (fixnum) ou du modèle (regexp) donné dans str. Renvoie nil si non trouvé. Si le deuxième paramètre est présent, il spécifie la position dans la chaîne pour terminer la recherche. Les caractères au-delà de ce point ne seront pas pris en compte.

str.rjust(integer, padstr = ' ')

Si integer est supérieur à la longueur de str, renvoie une nouvelle chaîne de longueur integer avec str justifiée à droite et complétée avec padstr; sinon, retourne str.

str.rstrip

Renvoie une copie de str avec les espaces de fin supprimés.

str.rstrip!

Supprime les espaces de fin de str, renvoyant nil si aucune modification n'a été apportée.

str.scan(pattern) [or]

str.scan(pattern) { |match, ...| block }

Les deux formes parcourent str, correspondant au modèle (qui peut être une expression rationnelle ou une chaîne). Pour chaque correspondance, un résultat est généré et ajouté au tableau de résultats ou transmis au bloc. Si le modèle ne contient aucun groupe, chaque résultat individuel est constitué de la chaîne correspondante, $ &. Si le modèle contient des groupes, chaque résultat individuel est lui-même un tableau contenant une entrée par groupe.

str.slice(fixnum) [or] str.slice(fixnum, fixnum) [or]

str.slice(range) [or] str.slice(regexp) [or]

str.slice(regexp, fixnum) [or] str.slice(other_str)

See str[fixnum], etc.

str.slice!(fixnum) [or] str.slice!(fixnum, fixnum) [or]

str.slice!(range) [or] str.slice!(regexp) [or]

str.slice!(other_str)

Supprime la partie spécifiée de str et renvoie la partie supprimée. Les formulaires qui prennent un Fixnum lèveront une IndexError si la valeur est hors limites; le formulaire Range lèvera une RangeError, et les formulaires Regexp et String ignoreront silencieusement l'affectation.

str.split(pattern = $, [limit])

Divise str en sous-chaînes en fonction d'un délimiteur, retournant un tableau de ces sous-chaînes.

Si pattern est une chaîne, son contenu est utilisé comme délimiteur lors du fractionnement de str. Si le motif est un seul espace, str est divisé sur un espace blanc, les espaces de début et les séries de caractères d'espaces contigus ignorés.

Si motif est une expression rationnelle, str est divisé là où le motif correspond. Chaque fois que le modèle correspond à une chaîne de longueur nulle, str est divisé en caractères individuels.

Si le motif est omis, la valeur de $; est utilisé. Si $; est nil (qui est la valeur par défaut), str est divisé sur un espace comme si `` était spécifié.

Si le paramètre limit est omis, les champs nuls de fin sont supprimés. Si limit est un nombre positif, ce nombre de champs au maximum sera renvoyé (si limit est 1, la chaîne entière est renvoyée comme seule entrée dans un tableau). S'il est négatif, il n'y a pas de limite au nombre de champs renvoyés et les champs nuls de fin ne sont pas supprimés.

str.squeeze([other_str]*)

Construit un ensemble de caractères à partir du ou des paramètres other_str en utilisant la procédure décrite pour String # count. Renvoie une nouvelle chaîne dans laquelle les exécutions du même caractère qui se produisent dans cet ensemble sont remplacées par un seul caractère. Si aucun argument n'est donné, toutes les exécutions de caractères identiques sont remplacées par un seul caractère.

str.squeeze!([other_str]*)

Met str en place, renvoyant soit str, soit nil si aucune modification n'a été apportée.

str.strip

Renvoie une copie de str avec les espaces de début et de fin supprimés.

str.strip!

Supprime les espaces de début et de fin de str. Renvoie nil si str n'a pas été modifié.

str.sub(pattern, replacement) [or]

str.sub(pattern) { |match| block }

Renvoie une copie de str avec la première occurrence de pattern remplacée par le remplacement ou la valeur du bloc. Le modèle sera généralement une expression rationnelle; s'il s'agit d'une chaîne, aucun métacaractère d'expression régulière ne sera interprété.

str.sub!(pattern, replacement) [or]

str.sub!(pattern) { |match| block }

Effectue les substitutions de String # sub en place, renvoyant str ou nil si aucune substitution n'a été effectuée.

str.succ [or] str.next

Renvoie le successeur de str.

str.succ! [or] str.next!

Équivaut à String # succ, mais modifie le récepteur en place.

str.sum(n = 16)

Renvoie une somme de contrôle de base de n bits des caractères de str, où n est le paramètre optionnel Fixnum, par défaut à 16. Le résultat est simplement la somme de la valeur binaire de chaque caractère de str modulo 2n - 1. Ce n'est pas un bonne somme de contrôle.

str.swapcase

Renvoie une copie de str avec des caractères alphabétiques majuscules convertis en caractères minuscules et minuscules convertis en majuscules.

str.swapcase!

Équivaut à String # swapcase, mais modifie le récepteur sur place, renvoyant str, ou nil si aucune modification n'a été effectuée.

str.to_f

> Renvoie le résultat de l'interprétation des premiers caractères de str comme un nombre à virgule flottante. Les caractères superflus après la fin d'un nombre valide sont ignorés. S'il n'y a pas de nombre valide au début de str, 0.0 est renvoyé. Cette méthode ne lève jamais d'exception.

str.to_i(base = 10)

Renvoie le résultat de l'interprétation des premiers caractères de str comme une base entière (base 2, 8, 10 ou 16). Les caractères superflus après la fin d'un nombre valide sont ignorés. S'il n'y a pas de nombre valide au début de str, 0 est renvoyé. Cette méthode ne lève jamais d'exception.

str.to_s [or] str.to_str

Renvoie le récepteur.

str.tr(from_str, to_str)

Renvoie une copie de str avec les caractères de from_str remplacés par les caractères correspondants de to_str. Si to_str est plus court que from_str, il est complété avec son dernier caractère. Les deux chaînes peuvent utiliser la notation c1.c2 pour désigner des plages de caractères, et from_str peut commencer par un ^, qui désigne tous les caractères sauf ceux répertoriés.

str.tr!(from_str, to_str)

Traduit str en place, en utilisant les mêmes règles que String # tr. Renvoie str, ou nil si aucune modification n'a été effectuée.

str.tr_s(from_str, to_str)

Traite une copie de str comme décrit sous String # tr, puis supprime les caractères en double dans les régions qui ont été affectées par la traduction.

str.tr_s!(from_str, to_str)

Exécute le traitement String # tr_s sur str en place, en retournant str ou nil si aucune modification n'a été apportée.

str.unpack(format)

> Décode str (qui peut contenir des données binaires) en fonction de la chaîne de format, renvoyant un tableau de chaque valeur extraite. La chaîne de format consiste en une séquence de directives à un seul caractère, résumées dans le tableau 18. Chaque directive peut être suivie d'un nombre, indiquant le nombre de répétitions avec cette directive. Un astérisque (*) utilisera tous les éléments restants. Les directives sSiIlL peuvent chacune être suivies d'un trait de soulignement (_) pour utiliser la taille native de la plateforme sous-jacente pour le type spécifié; sinon, il utilise une taille cohérente indépendante de la plate-forme. Les espaces sont ignorés dans la chaîne de format.

str.upcase

Renvoie une copie de str avec toutes les lettres minuscules remplacées par leurs équivalents en majuscules. L'opération est insensible aux paramètres régionaux. Seuls les caractères a à z sont concernés.

str.upcase!

Modifie le contenu de str en majuscules, en retournant nil si aucune modification n'est apportée.

str.upto(other_str) { |s| block }

Itère des valeurs successives, en commençant à str et en se terminant à other_str inclus, en passant chaque valeur à son tour au bloc. La méthode String # succ est utilisée pour générer chaque valeur.