« Programmation Ruby/Types standards » : différence entre les versions

Nous allons voir ici touttous les types que nous pouvons considérer comme "standards", dans le sens où nous les retrouvons dans la plupart des langages, et que ceux-ci sont directement intégrés à l'interpreteurinterpréteur (''built-in''). Néanmoins il ne faut pas perdre de vue qu'il sagits'agit en réalité d'objets.

Pour rappel les méthodes terminantdont le nom se termine par ''!'' sont non pures : elles modifient l'objet.

%q!j'utilise le caractère \:! pour ouvrir ou fermer la chaine, ' et " peuvent ainsi être utilisés sans \ !

Si nous avons plusieurs lignes de texte à écrire nous pouvons utiliser les caractères ''<<'' suivit d'un identifiant pour créer une chaine ayant les mêmes propriétés qu'une chaine entre double quote, ou les charactèrescaractères ''<<-'' suivitsuivis d'un identifiant entre simple quote pour créer un chaine de caractères ayant les mêmemêmes propriétés qu'une chaine entre simple quote :

Le dernier moyen d'obtenir une chainechaîne de caractères est d'utiliser la méthode ''to_s'' que la plupart des objets implémentent, ainsi :

Les chaînes de caractères peuvent être comparées entre elles comme indiqués dans le chapitre [[Programmation Ruby Controle#Expressions booléennes|Expressions booléennes]] grace aux méthodes ''<, <=, ==, >=, >''

"abcdef" <=> "ABCDEF" => 1 # Les caractères majusculemajuscules sont supérieurs aux caractères minuscules

La méthode est équivalente à ''<=>'', aà part que la casse n'est pas comparécomparée :

''length'' permet de connaitre la taille d'une chainechaîne de caractères :

''index'' renvoi l'index de la première occurence d'une sous chainechaîne dans la chainechaîne de caractères, renvoi ''nil'' si aucune occurence n'a été trouvée :

''rindex'' effectue le même travail à la différence près que la recherche se fait à partir de la fin de la chainechaîne de caractères :

A noté que si se second paramètre est négatif, alors l'index est compté à partir de la fin de la chainechaîne :

==== Opérateurs sur les chaineschaînes de caractères ====

L'opérateur de multiplication renvoie une chaine de caractères contenant ''n'' fois la chainechaîne représentéreprésentée par l'objet :

L'opérateur d'addition permet de concaténer deux chaineschaînes de caractères :

L'opérateur ''[]'' permet de récuperer un ou plusieurs caractères faisant parti d'une chainechaîne.

Si un entier est passé en paramètre, l'opérateur renverra le code ascii du caractère correspondant (le premier caractère est indéxeindexé par la valeur 0) :

maChaine[3] => 106 #Corespond Correspond au code ascii du 4ème caractère (j)

Si deux entiers sont passés en paramètres, l'opérateur renverra une sous-chainechaîne commençant à l'index passé en premier paramètre et de la longueur indiquée par le second élément :

Il est à noter que si l'index est négatif, ruby compte à partir de la fin de la chainechaîne :

L'opérateur ''[]='' permet de changer le contenu d'une chaine de caractères. L'utilisation est semblable à celle de ''[]'', à la différence que plutotplutôt que de renvoyer un ensemble de caractères, l'opérateur modifiera la chainechaîne :

On peut directement utiliser une chainechaîne de caractères ou une [[Programmation Ruby Types standards#Expression rationelle|expression rationelle]] :

==== Formatage de chainechaîne ====

''split'' permet de séparer les différents éléments d'une chainechaîne en fonction d'un ou plusieurs délimiteurs, par défaut ceux-ci sont les fins de ligne et les espaces (''\s'', ''\t'', ''\r'',''\n'' et ''\r\n''). La méthode renvoi un tableau contenant les différents éléments :

''chop'' et ''chop!'' permettent de supprimer le dernier caractère d'une chainechaîne, néanmois si les deux dernier caractères sont "''\r\n''", les deux caractères sont supprimés :

Si une chainechaîne de caractères est donnée en paramètre, celle-ci est supprimésupprimée si elle est termine la chainechaîne :

Pour rappel, les méthodeméthodes finissant par "''!''" sont des méthodes non pures : elles modifient l'objet appelant.

L'opérateur ''%'' permet de formater la chainechaîne de caractères. Le format utilisé est le même que celui de la fonction ''sprintf'' de ruby et de bien d'autres langages tel le [[Programmation C|''C'']]. Le format est décrit par le caractère ''%'' suivitsuivi d'un indicateur optionnel, un indicateur de taille, de précision et de type.

Les infidcateursindicateurs de typestype :

| e || converticonvertit un nombre entier sous sa forme exponentielle avec un chiffre avant la virgullevirgule, la précision indique le nombre de chiffrechiffres après la virgullevirgule (par défaut 6)

| E || comme ''e'' mais utilise le caractère majuscule ''E'' pour indiquéindiquer l'exponantexposant

| f || nombre flotantflottant, la précision indique le nombre de chiffres après la virgule

| g || comme ''e'' mais converti en nombre flotantflottant

| G || comme ''E'' mais converti en nombre flotantflottant

| s || chaine de caractères, si une précision est donnédonnée, alors elle indique le nombre de caractères

| u || nombre entier non signé (par d'indicateurpas de signe)

| x || hexadecimal en utilisant les caractères minuscules (par exemple ''f'')

| X || hexadecimal en utilisant les caractères majuscules (par exemple ''F'')

| 0 || ''tous'' || RempliRemplit le format avec des ''0'' plutotplutôt que des espaces

| . || ''tous'' || Prend l'argument suivant comme taille, sipour aligner à droite s'il est positif. Si l'argument est négatif, allignealigne à gauche

| G || Considère ''sizeof(double)'' caractères comme un double dans l'ordre réseau || Float

| g || Considère ''sizeof(float)'' caractères comme un flotant dans l'ordre réseau || Float

| M || Décode les chaineschaînes "quoted printable" || String

| m || Décode les chaineschaînes en Base64 || String

| P || Considère ''sizeof(char *)'' comme un pointeur et renvoi la taille de la chainechaîne ainsi référencée || String

| P || Considère ''sizeof(char *)'' comme un pointeur sur une chainechaîne terminéterminée par le caractère ''null'' (''\0'') || String

| U || Extrait une chainechaîne encodéencodée au format UTF8 comme des entiers non signés || Integer

| u || Extrait une chainechaîne encodéencodée en UU || String

| Z || Supprime les caractères ''null'' de fin || String

| @ || Se déplace du nombre donné en argument || N/A

La chainechaîne de format se compose d'un nombre de directivedirectives à piocher dans le tableau précédantprécédent, optionnelementoptionnellement suivitsuivi d'un nombre indiquant le nombre de fois qu'il faut répeterrépéter cette directive, un astérisque (''*'') correspondant a tous les éléments restant. Les directives ''s'',''S'',''i'',''I'',''l'' et ''L'' peuvent être suivitsuivis d'un underscore (''_'') indiquant de choisir le format natif du système.

Les itérateurs sont un mécanisme puissant de ruby, ils permetentpermettent de parcourir les éléments d'un objet. Nous verrons plus tard comment étendre facilement comme étendre sa propre classe avec des itérateurs. Pour chaque type que nous allons voir, nous allons voir ses itérateurs. A l'heure actuelle considérons simplement un itérateur comme une méthode prenant un bloc pour paramètre (et d'ailleurs c'est ce que les itérateurs sont : de simples méthodes).

''succ'' se contente de renvoyer l'élément succédant à la chainechaîne, en pratique ''succ'' incrémente le dernier caractère alphanumérique de la chainechaîne, si celui-ci àa ateindatteint sa limite, ''succ'' incrémentera l'avant dernier caractère et ainsi de suite:

''upto'' itère à travers les valeurs successivesuccessives d'une chainechaîne, jusqu'aà arrivéarriver à la chainechaîne passépassée en paramètre. La méhode incrémente à partir de la dernière valeur alphanumérique de la chainechaîne :

''each_byte'' permet d'itérer à travers la chainechaîne de caractères, octet par octet,. laLa valeur qui sera envoyée au bloc sera le code ascii (donc un entier) du caractère :

En ruby les valeurs numériques sont soit flottanteflottantes soit entièreentières et sont de taille infiniesinfinie (jusqu'auà la limite de mémoire du système).

Plus tôt dans le livre, nous avons indiqué qu'un type entier est de type ''Integer'',. enEn fait nous avons menti,. leLe type Integer permet en réalité de cacher le type réel de la valeur. En effet pour, les valeurs inférieurs aux valeurs d'un entier sur le système (donc en général 32 ou 64 bits) sont en réalité de type ''Fixnum'',. auAu dessusdelà, elles seront de types ''Bignum''. En pratique la conversion est transparente pour le développeur :

En ruby une valeur numérique peut s'écrire de différente forme, notament en fonction de la base utiliséutilisée.

Classiquement, une valeur numérique peut s'écrire comme une suite de chiffre,chiffres séparéséparés éventuellement par des caractères de soulignement ( ''_'') qui seront ignorés lors de l'interprétation. Une valeur négative est simplement préfixépréfixée par le signe moinmoins (''-'') :

Certains objets, comme l'objet ''String'', possèdepossèdent une méthode ''to_i" qui renvoi si possible une valeur entière, et ''to_f'' qui renvoi si possible un flotant :

Si la chaîne contient des éléments non numériquenumériques, à l'exception du caractère de soulignement ou du signe moinmoins, la valeur renvoyée sera celle de la première valeur numérique trouvétrouvée et précédant les autres caractères :

ATTENTION: Le type renvoyé est du type des opérateursopérandes, ainsi si la division n'est pas entière, seul le dividende est renvoyé:

par contre, si nous utilisons desau flottantsmoins un flottant, le type renvoyé sera de type flottant :

9.0/4.0 => 2.25

Une division par 0 lève une exception (nous verrons les exceptions plus tard, il suffit de considérer à l'heure actuelle qu'il s'agit d'une erreur) et intérrompintérrompt le courcours du programme si celle-ci n'est pas interceptée :

L'opérateur ''**'' permet d'augmenter une valeur numérique à la puissance indiquéindiquée en paramètre :

La classe ''Integer '' propose également certains itérateurs, comme pour tout autresautre itérateursitérateur, ceux-ci prennent un ou plusieurs paramètres ainsi qu'un bloc de code.

''upto'' et ''downto'' permetentpermettent respectivement d'itérer à partir de la valeur de l'objet jusqu'aà la valeur passépassée en paramètre, respectivement en incrémentant ou en décrémentant :

''step'' ressemble à ''upto'' et ''downto'' à part que l'on peut ici préciser le pas :

5.step(48, 5) do |i| print i.to_s+'..' end #ici le second paramètre corespondcorrespond au pas

Les expressions rationelles (également nommésnommées expressions régulières) sont un mécanisme puissant mais qui peut être complexe. Elles permettent des recherches dans une chaîneschaîne de caractères selon des critèrecritères ou un modèle de recherche précis. Ceci permet la sélection d'une sous chaîne de caractères, ou la manipulation des chaînes ainsi trouvéstrouvées (typiquement une substitution).