# Programmation Ruby/Types standards
## Introduction et installation

* Introduction
* Installation
* Premiers essais

## Syntaxe et types

* Syntaxe, Portée, Types
* Expressions de contrôle et boucles
* Types standards
* Conteneurs

## Programmation orientée objet

* Les classes
* Les méthodes
* Les accesseurs
* Héritage
* Les exceptions
* Les mixins
* Les modules

## Utiliser Ruby

* La bibliothèque standard (stdlib)
* Ruby et le texte non structuré
* Programmation concurrente
* Programmation distribuée
* Persistance des données
* Bases de données et ORM
* Ruby et le Web
* Programmation Ruby/Manipuler des fichiers
* Ruby et les services
* Des interfaces graphiques avec Ruby
* Réflexion
* Exemples de code

## Pour les programmeurs...

* Pour les programmeurs Java
* Pour les programmeurs Python
* Pour les programmeurs PHP

## Outils autour du langage

* Interactive Ruby Shell
* Le débuggueur
* Le profileur
* Les tests unitaires
* La documentation
* Le packaging (gems)
* Rake
* Étendre Ruby
* Les différentes implémentations du langage

## Références

* Mots Réservés
* Variables globales prédéfinies
* Caractères d'échappements
* Webographie

## Introduction et installation

* Introduction
* Installation
* Premiers essais

## Syntaxe et types

* Syntaxe, Portée, Types
* Expressions de contrôle et boucles
* Types standards
* Conteneurs

## Programmation orientée objet

* Les classes
* Les méthodes
* Les accesseurs
* Héritage
* Les exceptions
* Les mixins
* Les modules

## Utiliser Ruby

* La bibliothèque standard (stdlib)
* Ruby et le texte non structuré
* Programmation concurrente
* Programmation distribuée
* Persistance des données
* Bases de données et ORM
* Ruby et le Web
* Programmation Ruby/Manipuler des fichiers
* Ruby et les services
* Des interfaces graphiques avec Ruby
* Réflexion
* Exemples de code

## Pour les programmeurs...

* Pour les programmeurs Java
* Pour les programmeurs Python
* Pour les programmeurs PHP

## Outils autour du langage

* Interactive Ruby Shell
* Le débuggueur
* Le profileur
* Les tests unitaires
* La documentation
* Le packaging (gems)
* Rake
* Étendre Ruby
* Les différentes implémentations du langage

## Références

* Mots Réservés
* Variables globales prédéfinies
* Caractères d'échappements
* Webographie
[ Modifier le sommaire ]
Nous allons voir ici tous 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'interpréteur (built-in). Néanmoins il ne faut pas perdre de vue qu'il s'agit en réalité d'objets.
Pour rappel les méthodes dont le nom se termine par ! sont non pures : elles modifient l'objet.

## Chaîne de caractères

En ruby les chaînes de caractères sont représentées par l'objet "String". En réalité cet objet contient et permet la manipulation d'un nombre indéfini d'octets, typiquement des caractères, nous pourrons néanmoins y stocker tout type de données binaires ou non.

### Créer une chaîne de caractères

En ruby il existe une multitude de manières de créer une chaîne de caractères, par exemple en créant une instance de l'objet String :
Mais le moyen le plus courant de créer une chaîne est de la placer entre simple quote (') ou entre double quote ("). Néanmoins ces deux moyens ne sont pas équivalents : en utilisant les doubles quotes ruby évaluera les expressions contenues entre #{ et }, ainsi que les caractères d'échappements.
Dans une chaîne de caractère \ a une valeur particulière, elle permet de placer un caractères d'échappements. Le caractère \ indique à ruby que le caractère suivant possède une valeur particulière : ainsi "\n" représente une nouvelle ligne. Les caractères d'échappements ne sont pas pris en compte avec une chaîne de caractères débutant par un simple quote, néanmoins nous pouvons l'utiliser pour indiquer à Ruby de considérer le simple quote ou le backslash suivant comme faisant partie de la chaîne :
Un autre moyen de créer une chaîne est d'utiliser %q ou %Q, qui équivalent respectivement au simple et au double quote. Néanmoins l'utilisation de %q ou %Q permet de définir le caractère d'ouverture et de fermeture de la chaîne :
Si nous avons plusieurs lignes de texte à écrire nous pouvons utiliser les caractères << suivit d'un identifiant pour créer une chaîne ayant les mêmes propriétés qu'une chaîne entre double quote, ou les caractères <<- suivis d'un identifiant entre simple quote pour créer une chaîne de caractères ayant les mêmes propriétés qu'une chaîne entre simple quote :
Le dernier moyen d'obtenir une chaîne de caractères est d'utiliser la méthode to_s que la plupart des objets implémentent, ainsi :

### Comparaisons de chaînes

Les chaînes de caractères peuvent être comparées comme indiqué dans le chapitre Expressions booléennes grâce aux méthodes <, <=, ==, >=, >
La méthode est équivalente à <=>, à part que la casse n'est pas comparée :

### Manipulation de chaînes
#### Taille d'une chaîne et index des caractères
##### length

length permet de connaître la taille d'une chaîne de caractères :
"Bonjour le monde".length => 16

##### index et rindex

index renvoie l'index de la première occurrence d'une sous chaîne dans la chaîne de caractères, renvoi nil si aucune occurrence n'a été trouvée :
Si un entier est donné en second paramètre, celui-ci indique l'index où commencer la recherche.
Nous pouvons également utiliser une expression rationnelle.
rindex effectue le même travail à la différence près que la recherche se fait à partir de la fin de la chaîne de caractères :
Si le second paramètre est présent, la recherche commencera au caractère indiqué :
À noter que si le second paramètre est négatif, alors l'index est compté à partir de la fin de la chaîne :

#### Opérateurs sur les chaînes de caractères

L'opérateur de multiplication renvoie une chaîne de caractères contenant n fois la chaîne représentée par l'objet :
"Ho! " * 3 => Ho! Ho! Ho!
L'opérateur d'addition permet de concaténer deux chaînes de caractères :

##### et=

L'opérateur permet de récupérer un ou plusieurs caractères faisant partie d'une chaî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 indexé par la valeur 0) :
Si deux entiers sont passés en paramètres, l'opérateur renverra une sous-chaîne commençant à l'index passé en premier paramètre et de longueur indiquée par le second élément :
On peut également indiquer un intervalle :
Il est à noter que si l'index est négatif, ruby compte à partir de la fin de la chaîne :
On peut également utiliser une expression rationnelle, nous verrons cela plus en détail dans le chapitre correspondant.
L'opérateur= permet de changer le contenu d'une chaîne de caractères. L'utilisation est semblable à celle de, à la différence que plutôt que de renvoyer un ensemble de caractères, l'opérateur modifiera la chaîne :
Si deux entiers sont passés en paramètres, ruby remplacera la chaîne commençant à l'index passé en première paramètre et d'une longueur passée en second paramètre :
On peut directement utiliser une chaîne de caractères ou une expression rationnelle :

#### Formatage de chaîne
##### split

split permet de séparer les différents éléments d'une chaî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 :
Si un entier est donné en paramètre, le tableau résultant n'aura comme nombre d'éléments la valeur de cet entier :
Nous pouvons également utiliser une expression rationnelle.

##### chomp, chomp!, chop et chop!

chop et chop! permettent de supprimer le dernier caractère d'une chaîne, néanmoins si les deux derniers caractères sont "\r\n", les deux caractères sont supprimés :
chomp et chomp! suppriment le dernier caractère seulement si celui-ci est un caractère de fin de ligne (soit "\r", "\n" et "\r\n") :
Si une chaîne de caractères est donnée en paramètre, celle-ci est supprimée si elle est termine la chaîne :
Pour rappel, les méthodes finissant par "!" sont des méthodes non pures : elles modifient l'objet appelant.

##### downcase, downcase!, upcase, upcase!, swapcase, swapcase!, capitalize et capitalize!

downcase et upcase permettent de passer respectivement tous les caractères en majuscules ou en minuscules.
swapcase inverse la casse :
capitalize ne met que le premier caractère en majuscule :
L'opérateur % permet de formater la chaî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 C. Le format est décrit par le caractère % suivi d'un indicateur optionnel, un indicateur de taille, de précision et de type.
Les indicateurs de type :
| Indicateur | Description |
| b | données binaire |
| c | caractère |
| d ou i | nombre entier |
| e | convertit un nombre entier sous sa forme exponentielle avec un chiffre avant la virgule, la précision indique le nombre de chiffres après la virgule (par défaut 6) |
| E | comme e mais utilise le caractère majuscule E pour indiquer l'exposant |
| f | nombre flottant, la précision indique le nombre de chiffres après la virgule |
| g | comme e mais converti en nombre flottant |
| G | comme E mais converti en nombre flottant |
| o | nombre octal |
| p | symbole |
| s | chaîne de caractères, si une précision est donnée, alors elle indique le nombre de caractères |
| u | nombre entier non signé (pas de signe) |
| x | hexadécimal en utilisant les caractères minuscules (par exemple f) |
| X | hexadécimal en utilisant les caractères majuscules (par exemple F) |
Format :
| Indicateur | Types applicable | Description |
| espace | bdeEfgGioxXu | Laisse un espace au début des nombres positifs |
| # | bdeEfgGioxXu | Format alternatif, pour les types o, x, X et b préfixe respectivement le résultat par 0, 0x, 0X, et 0b |
| + | bdeEfgGioxXu | Ajoute un + au début des nombres positifs |
| - | bdeEfgGioxXu | Ajoute un - au début des nombres négatifs |
| 0 | tous | Remplit le format avec des 0 plutôt que des espaces |
| . | tous | Prend l'argument suivant comme taille pour aligner à droite s'il est positif. Si l'argument est négatif, aligne à gauche |
Si plusieurs éléments doivent être formatés, il faut passer les paramètres dans un tableau :

##### unpack

La méthode unpack permet de décoder des chaînes de caractères (ou contenant des données binaires) en corrélation avec une chaîne de format.
| Indicateur | Description | Type renvoyé |
| A | Chaîne de caractères en supprimant les caractères vides (espace, tabulation...) | String |
| a | Chaîne de caractères | String |
| B | Extrait les bits de chaque caractère (bit de poids fort en premier) | String |
| b | Extrait les bits de chaque caractère (bit de poids faible en premier) | String |
| C | Extrait un caractère comme un entier non signé | Fixnum |
| c | Extrait un caractère comme un entier signé | Fixnum |
| d | Considère sizeof(double) caractères comme un double | Float |
| E | Considère sizeof(double) caractères comme un double en little-endian | Float |
| e | Considère sizeof(float) caractères comme un flottant en little-endian | Float |
| f | Considère sizeof(float) caractères comme un flottant | Float |
| 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 flottant dans l'ordre réseau | Float |
| H | Extrait le code hexadécimal de chaque caractère (bit de poids fort en premier) | String |
| h | Extrait le code hexadécimal de chaque caractère (bit de poids faible en premier) | String |
| I | Considère sizeof(int) caractères comme un entier non signé | Integer |
| i | Considère sizeof(int) caractères comme un entier signé | Integer |
| L | Considère 4 caractères consécutifs comme un entier long non signé | Integer |
| i | Considère 4 caractères consécutifs comme un entier long signé | Integer |
| M | Décode les chaînes "quoted printable" | String |
| m | Décode les chaînes en Base64 | String |
| N | Considère 4 caractères consécutifs comme un entier long non signé dans l'ordre réseau | Fixnum |
| n | Considère 2 caractères consécutifs comme un entier court non signé dans l'ordre du réseau | Fixnum |
| P | Considère sizeof(char *) comme un pointeur et renvoi la taille de la chaîne ainsi référencée | String |
| P | Considère sizeof(char *) comme un pointeur sur une chaîne terminée par le caractère null (\0) | String |
| S | Considère 2 caractères consécutifs comme un entier court non signé dans l'ordre natif du système | Fixnum |
| s | Considère 2 caractères consécutifs comme un entier court signé dans l'ordre natif du système | Fixnum |
| U | Extrait une chaîne encodée au format UTF8 comme des entiers non signés | Integer |
| u | Extrait une chaîne encodée en UU | String |
| V | Considère 4 caractères consécutifs comme un entier long non signé en "little endian" | Fixnum |
| v | Considère 2 caractères consécutifs comme un entier court non signé en "little endian" | Fixnum |
| X | Retourne en arrière d'un caractère | N/A |
| x | Avance d'un caractère | N/A |
| Z | Supprime les caractères null de fin | String |
| @ | Se déplace du nombre donné en argument | N/A |
La chaîne de format se compose d'un nombre de directives à piocher dans le tableau précédent, facultativement suivi d'un nombre indiquant le nombre de fois qu'il faut ré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 suivis d'un underscore (_) indiquant de choisir le format natif du système.
Exemples :

### Itérateurs

Les itérateurs sont un mécanisme puissant de ruby, ils permettent de parcourir les éléments d'un objet. Nous verrons plus tard comment étendre facilement sa propre classe avec des itérateurs. Pour chaque type que nous allons voir, nous allons voir ses itérateurs. À 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, succ! et upto

succ se contente de renvoyer l'élément succédant à la chaîne, en pratique succ incrémente le dernier caractère alphanumérique de la chaîne, si celui-ci a atteint sa limite, succ incrémentera l'avant-dernier caractère et ainsi de suite:
upto itère à travers les valeurs successives d'une chaîne, jusqu'à arriver à la chaîne passée en paramètre. La méthode incrémente à partir de la dernière valeur alphanumérique de la chaîne :

#### each_byte

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

#### each

each permet d'itérer à travers chaque ligne contenue dans une String :
Il est à noter que l'itérateur each est celui appelé par la construction for..in' :

## Valeur numérique

En ruby les valeurs numériques sont soit flottantes soit entières et sont de taille infinie (jusqu'à 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. En fait nous avons menti. Le type Integer permet en réalité de cacher le type réel de la valeur. En effet, les valeurs inférieures 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. Au delà, elles seront de types Bignum. En pratique la conversion est transparente pour le développeur :

### Syntaxe

En ruby une valeur numérique peut s'écrire de différente forme, notamment en fonction de la base utilisée.
Classiquement, une valeur numérique peut s'écrire comme une suite de chiffres 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ée par le signe moins (-) :
On peut également travailler dans une autre base en préfixant la valeur numérique. Ainsi en préfixant avec 0 (zéro) on indique l'utilisation d'un nombre en base octale, 0x pour un nombre en hexadécimal et 0b pour un nombre en binaire :

#### Utilisation

Un objet correspondant à une valeur numérique s'instancie simplement en écrivant cette valeur :
Certains objets, comme l'objet String, possèdent une méthode to_i qui renvoie si possible une valeur entière, et to_f qui renvoi si possible un flottant :
Si la chaîne contient des éléments non numériques, à l'exception du caractère de soulignement ou du signe moins, la valeur renvoyée sera celle de la première valeur numérique trouvée et précédant les autres caractères :

### "Opérateurs" arithmétiques

Attention : En Ruby les opérateurs n'existent pas, ce sont des méthodes inclusent dans l'objet Ruby père Object. On parle donc ici d'"opérateur" par analogie avec les langages orientés objet et procéduraux.
il faut bien comprendre que :
équivaut à
tel que
Pour simplifier la lecture, on accordera l'usage de cet abus de langage dans le reste du document pour faciliter le passage d'un autre langage vers Ruby
L'opérateur + permet d'additionner 2 valeurs numériques :
L'opérateur - permet de soustraire une valeur numérique à une autre :
L'opérateur * permet de multiplier 2 valeurs numériques :
L'opérateur / permet de diviser une valeur numérique par une autre :
ATTENTION: Le type renvoyé est du type des opérandes, ainsi si la division n'est pas entière, seul le dividende est renvoyé:
par contre, si nous utilisons au moins un flottant, le type renvoyé sera de type flottant :
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 interrompt le cours du programme si celle-ci n'est pas interceptée :
L'opérateur ** permet d'augmenter une valeur numérique à la puissance indiquée en paramètre :
L'opérateur % (modulo) permet de connaître le reste d'une division :

### Itérateurs

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

#### succ

succ permet de récupérer la valeur numérique suivante :

#### times

times permet de créer une boucle allant de 0 à la valeur de l'objet :

#### upto et downto

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

#### step

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

## Expression rationnelle

Les expressions rationnelles (parfois nommées à tort expressions régulières) sont un mécanisme puissant mais qui peut être complexe. Elles permettent des recherches dans une chaîne de caractères selon des critè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ées (typiquement une substitution).
Ruby propose une classe pour l'utilisation des expressions rationnelles, les développeurs Perl seront heureux car son utilisation en Ruby est quasi-identique (voir Catégorie:Expressions rationnelles).