# Programmation Ruby/Version imprimable

* Si vous imprimez cette page, choisissez « Aperçu avant impression » dans votre navigateur, ou cliquez sur le lien Version imprimable dans la boîte à outils, vous verrez cette page sans ce message, ni éléments de navigation sur la gauche ou en haut.
* Cliquez sur Rafraîchir cette page pour obtenir la dernière version du wikilivre.
* Pour plus d'informations sur les version imprimables, y compris la manière d'obtenir une version PDF, vous pouvez lire l'article Versions imprimables.
Une version à jour et éditable de ce livre est disponible sur Wikilivres, une bibliothèque de livres pédagogiques, à l'URL : https://fr.wikibooks.org/wiki/Programmation_Ruby

# Introduction
## 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 ]
Ruby, ou la langue rouge, est un langage interprété comparable à Perl, Python et Smalltalk pour son approche objet.
Il est capable de gérer des expressions régulières en langue japonaise, cette langue ayant la caractéristique de regrouper trois systèmes graphiques différents, quatre si l'on compte les caractères romains de plus en plus utilisés pour les mots d'origine étrangère.
De plus, Ruby est complètement objet alors que les aspects objets de Python ne sont pas intrinsèques au langage.
Ruby fut développé dans l'idée de pouvoir programmer tout en restant concentré sur le côté créatif du développement, ainsi ruby se veut aussi souple que Perl, tout en restant plus cohérent, notamment via son approche entièrement objet (y compris les types primaires), à l'exception des expressions de contrôle (if-then-else, for,...). Le langage est conçu sur le principe de moindre surprise (PoLS : Principle of Least Surprise), rendant le langage plus "sûr" que de nombreux autres langages de script.
Ruby est interprété, ce qui en fait un outil de développement rapide, en contrepartie d'un certain relâchement des performances. Ces nombreux avantages font qu'il connaît un grand succès au Japon (son pays d'origine), et gagne petit à petit du terrain, notamment dans le domaine de la recherche.

# Installation
## 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 ]

## Linux

Sur la plupart des systèmes Linux ou BSD, Ruby est inclus dans la distribution, référez-vous à sa documentation pour savoir comment installer de nouveaux packages.
Veuillez à installer tout le nécessaire :
* ruby
* irb (un interpréteur interactif)
* ri qui permet d'accéder à de la documentation
* rubygems qui permet de télécharger et d'installer simplement des bibliothèques à la manière d'un gestionnaire de paquet
... et le superflu :
* rubybook, un livre sur Ruby en anglais

## Windows

Le plus simple est de télécharger et lancer (en tant qu'administrateur) l'installeur sur http://rubyinstaller.org/.
Mais par ailleurs les sources sont accessibles ici.

## Mac OS X

Mac OS X Leopard intègre Ruby d'origine. Pour les versions précédentes du système, il existe comme pour Windows un One-Click Installer

## Autres systèmes

Si Ruby supporte votre système vous pouvez télécharger les sources à partir de cette url :
ftp://ftp.ruby-lang.org/pub/ruby/stable-snapshot.tar.gz

# Premiers essais
## 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 ]
Pour faire les premiers essais avec Ruby, nous allons utiliser l'outil irb, un interpréteur Ruby très pratique pour tester et déboguer.
Pour le lancer sous Windows un raccourci a été défini au chapitre précédent, et avec Unix à partir d'un terminal via la commande irb :
Pour ne pas déroger à la règle, nous allons pour premier exemple dire bonjour :
Ceci renverra :
soit l'effet produit par notre fonction (l'affichage de la chaîne "Hello World"), et la valeur de retour de celle-ci, dans notre cas nil.
Pour un langage objet, cet exemple n'est pas très adapté. Il faut néanmoins savoir que tout code écrit en dehors d'une classe ou d'un module fait partie de la classe Object.
On aurait également pu écrire cet exemple de cette manière :
L'approche objet est ici plus évidente : la méthode "<<" de l'objet STDOUT est appelée avec « "Hello" << " " + "World" » comme paramètre. De même on appelle la méthode "<<" de l'objet « "Hello" » (qui est une instance de l'objet String).
On découvre ici le modèle tout objet de Ruby. En effet, celui-ci ne comporte pas de type primaire, ainsi, une chaîne de caractères ou un nombre sont des objets, comme on peut le voir avec la méthode Object.class :
Bien sûr, chacun de ces objets possède ses propres méthodes, que l'on peut lister ainsi :
ou encore dans un contexte précis :
On constate certaines particularités syntaxiques ; nous les détaillerons plus tard même si elles sont assez claires ; par exemple une méthode dont le nom se termine par "?" indique que celle-ci renvoie un booléen.
Pour plus d'informations sur un objet ou une méthode, vous pouvez, à partir d'un terminal, exécuter la commande « ri » :
Si une méthode est incluse dans plusieurs objets, « ri » vous proposera une liste de choix possibles.
Toute méthode peut être redéfinie :
Toutes les méthodes peuvent ainsi être redéfinies, cependant, cette fonctionnalité est à utiliser avec précaution.
Pour finir cette présentation nous allons voir la notion de bloc en Ruby, et voir comment ceux-ci peuvent être utilisés. Par exemple :
Ici nous voyons que le bloc délimité par do et end (Il est à noter que l'on peut également délimiter les blocs par des accolades ouvrantes et fermantes { } ) est envoyé en paramètre à la méthode times de l'objet Fixnum. Les valeurs entre pipes (ici la variable i) indiquent les paramètres que la méthode passe au bloc. Ici, la méthode times va donc appeler 5 fois le bloc en y passant en paramètre un entier valant au départ 0 et qui sera incrémenté de 1 à chaque appel du bloc.
Tous ces concepts seront vus en détail dans les chapitres suivants.

# Syntaxe
## 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 ]

# Syntaxe du langage

La syntaxe de ruby est à la fois simple, car elle permet de lire simplement le code source, et complexe, car à la manière du Perl il y a plusieurs manières d'écrire une même instruction.

## Nomenclatures

Notons que par nomenclature les méthodes terminant par un point d'exclamation ! sont non pures : elles modifient l'objet. Les méthodes terminant par un point d'interrogation ? renvoient un booléen (vrai ou faux)

## Identifiants

Tout nom (que cela soit pour les variables, méthodes, classes...) doit respecter une certaine nomenclature : tout identifiant doit commencer soit par une lettre, soit par un souligné (_), et bien sur ne doit pas être un des mots réservés du langage.
Exemples :

## Commentaires

En Ruby, les commentaires peuvent prendre deux formes. La plus commune insère un commentaire sur une seule ligne et débute par le caractère dièse ("#"). Le reste de la ligne est alors considéré comme un commentaire.
Une seconde forme permettant d'insérer des commentaires sur plusieurs lignes est plutôt réservée à l'écriture de documentation. Il s'agit de délimiter les lignes de commentaires par une ligne "=begin" et une ligne "=end".

# Typage de canard

Si vous avez déjà utilisé des langages typés tels que C ou Java, vous êtes familier de la notion de "type". Ces langages attribuent à chaque variable un "type" c'est-à-dire un ensemble de choses qu'elle est capable de faire. Lorsqu'une variable a un type donné, le langage considère qu'on ne peut pas demander autre chose à celle-ci que ce que son type l'y autorise. Ainsi les langages typés détectent une erreur de programmation dans un programme avant même de l'utiliser en vérifiant simplement que ce que l'on demande à chaque variable est bien à la portée de son type.
Ruby est fondé sur l'approche inverse, il fait l'hypothèse qu'à priori, on peut demander n'importe quoi à une variable et qu'il détectera une erreur seulement lorsqu'une variable ne sera pas en mesure de faire ce qu'on lui demande au moment où on lui demande. C'est en cela que réside tout l'intérêt de ce langage: il autorise les variables à acquérir ou perdre des fonctionnalités au cours de leur existence. Pour cette raison, ceux habitués au langages typés seront surpris de constater que les paramètres des méthodes n'ont pas de type en Ruby: cette notion n'existe simplement pas.
Ce mécanisme est parfois nommé "typage de canard" (Duck Typing) et résumé ainsi: "si ça a des plumes et que ça fait 'coincoin' alors c'est sûrement un canard". Illustrons cela avec un exemple:
Comme vous pouvez le constater, même si les humains ne font pas coincoin d'après la classe Humain, certains peuvent apprendre et Ruby laissera faire les imitateurs de canards.
Ce mécanisme, permet d'enrichir certains objets comme nous venons de le voir, mais il permet surtout d'écrire du code générique (réutilisable) sans trop d'effort:

# Portée et syntaxe des variables

La portée des différentes variables est définie par leur syntaxe :

## Variable locale

Une variable locale doit être nommée avec pour premier caractère soit une minuscule, soit un caractère souligné (underscore).
exemple :
La portée d'une variable locale est le bloc courant, sauf si elle est définie en dehors du bloc :

## Variable globale

Une variable globale doit être préfixée avec dollar ($) comme premier caractère :
exemple:
Comme son nom l'indique, une variable globale est accessible dans tout le programme :

## Attribut ou variable d'instance

Une variable d'instance est une variable qui n'est accessible qu'après l'instanciation d'un objet. La variable sera alors accessible en utilisant cette syntaxe : <Nom de l'instance>.<Nom de la variable>. Son nom doit être préfixé avec le caractère arobase (@)
Exemple :

## Attributs ou variable de classe

Une variable de classe est commune à toutes les instances d'une même classe. Son nom est préfixé par deux arobases (@@).
Exemple :

## Constantes

Une constante définit un élément qui ne pourra jamais changer au cours de l'exécution du programme. Une constante débute toujours par une majuscule, mais vous pouvez n'utiliser que des majuscules pour les identifier des noms de classe dans votre code
Note : En Ruby, les noms de classes sont eux aussi des constantes.

## Les symboles

Les symboles sont des idiomes qui référencent en mémoire, de façon unique, les chaînes de caractères, en s'associant à l'identifiant d'un objet String dans l'espace de nom du contexte d'exécution de programme en cours.
Note : En Ruby, il n'y a que des références aux objets Ruby
En Ruby tout est objet, tout appel de méthode est un message envoyé à un objet. Voir la méthode send d'un objet.
donc :
revient à envoyer le message symbolique :ma_methode à l'objet mon_objet
Les symboles sont couramment utilisés pour la construction d'accesseurs sur les attributs :
Ils servent aussi dans les Hash pour servir de clé de référence :

# Expressions

En ruby une expression correspond à tout ce que peut renvoyer un objet, soit à peu près tout :

## Parenthésage

Le parenthésage permet de spécifier des priorités lors de l'interprétation. Comme pour une formule mathématique, les expressions entre parenthèses sont évaluées en premier :

## Assignation

L'assignation d'un objet à une variable se fait avec le caractère égal (=). La variable doit être l'élément de gauche, l'objet ou l'expression doit se trouver à droite :
De même grace à l'objet Proc il est possible d'affecter à une variable un bloc de code :
Nous étudierons par la suite plus en détail l'objet Proc.

## Assignations parallèles

Ruby permet d'assigner plusieurs variables à la fois, en séparant celles-ci par une virgule (,). Par exemple pour intervertir deux variables :
De même nous pouvons affecter les valeurs d'un tableau à plusieurs variables (nous verrons l'utilisation des tableaux plus tard).

# Appels système

Les appels système peuvent se faire de différentes manières

## Quotes inversées

Appel d'une commande et récupération de la sortie dans un tableau
Pour passer des variables, il faut absolument entourer la variable de # par exemple avec :
si l'on se contente de mettre #a
Par contre :

## IO.popen

Il est également possible d'utiliser la commande IO.popen :
On peut alors récupérer la sortie de la commande avec :
Il est bien sûr possible de concaténer en une seule ligne avec :
Et de concaténer la commande et les arguments :
Cela parait plus compliqué que d'utiliser les simples quotes inversées, mais a l'avantage de ne pas appeler un interpréteur de commande.

## Commande system

On peut également utiliser la commande system. Elle retourne le code retour de la commande et affiche la sortie de la commande sur la sortie standard.
et à l'écran :

## Commande exec

La commande exec, exécute la commande puis quitte définitivement ruby, donc pas de retour
Quitte le programme en affichant la sortie standard :

# Contrôle
## Méthodes logiques

Une expression booléenne est toute expression qui renvoie après évaluation vrai (true) ou faux (false). Une valeur booléenne peut être de type booléen (true ou false)
Attention:
* 0 est true => Objet Fixnum de valeur 0
* "" est true => Objet String de valeur ""
* 'False' est true => Objet String de valeur 'False'
Il s'agit ici d'une autre des caractéristiques des langages 'tout objet' ou même les nombres sont des objets. Tout objet est true.
Une autre caractéristique de Ruby et de tous les langages "tout objet", est que les "opérateurs", décrit ci-dessous, comme on les appelle dans les langages orientés objet ou procéduraux, sont en réalités des méthodes d'instance. En règles générale, le développeur doit implémenter lui même ses méthodes. Néanmoins certaines d'entre, dont les equivalents d'"opérateurs", sont pré-définies dans la classe Object, mère de toutes les autres classes, ou encore dans un module. Nous reviendrons sur ces concepts dans le chapitre traitant de la programmation objet.
Les exemples, ici, utilisent des objets "standards" pour un souci de clarté, ils peuvent être remplacés par des expressions placées entre parenthèses. Ainsi :
équivaut à

### defined?

defined? permet de vérifier l'existence d'une variable, l'opérateur renvoie nil si la variable n'existe pas, sinon renvoi une description :

### eql?

eql? teste si 2 variables ou valeurs sont égales et du même type, renvoi true si c'est le cas, sinon false.

### equal?

equal? renvoie true si les deux objets comparés sont en réalité un même objet (même id), sinon renvoie false.
== permet de tester l'égalité entre les valeurs de deux éléments :
!= permet de tester l'inégalité entre les valeurs de deux éléments :
<=> sert à comparer deux variables, cette méthode n'est pas à proprement parler un opérateur booléen. En effet celle-ci renvoie -1, 0 ou 1 si, le premier élément est respectivement inférieur, égal ou supérieur au second, et renvoie nil si les types sont différents.
Pour deux valeurs numériques cet opérateur retourne donc le signe de la différence entre celles-ci.

### < et <=

< et <= correspondent respectivement à "inférieur" et "inférieur ou égal à" :

### > et >=

> et >= correspondent respectivement à "supérieur à" et "supérieur ou égal à" :

### not et !

not et ! exprime la négation, l'opérateur "inverse" l'élément placé juste après, ainsi :
De même, on peut exprimer la négation sur une expression si celle-ci se trouve entre parenthèses :

### and et &&

and et && correspondent au "et logique" :
Dans un souci d'optimisation, Ruby teste la première expression, et si celle-ci est fausse, il ne teste pas la seconde.

### or et ||

or et || correspondent au "ou logique"
Dans un souci d'optimisation, Ruby teste la première expression, et si celle-ci est vraie, il ne teste pas la seconde.

## Les expressions conditionnelles

Une expression conditionnelle sert à réagir en fonction d'un élément donné.

### Expression IF...THEN...ELSE

En algorithmique :
se traduit en Ruby par :
La condition peut être une expression, à condition que celle-ci soit une expression booléenne (vrai ou faux), ou une valeur numérique (0 ayant valeur de faux).
donc :
équivaut à
qui équivaut à
de même :
équivaut à
qui équivaut à
Une expression conditionnelle peut être l'élément ouvrant d'un bloc, ou succéder à une expression si celle-ci tient sur une ligne, dans ce denier cas on ne peut utiliser else :
équivaut à
Le pendant de if est unless (sauf si) et suit les mêmes règles, toutefois l'instruction n'est exécuté que si la condition est fausse :
À noter que pour faciliter la lecture, ruby permet de faire suivre l'expression testée du mot clef then :

### Expression CASE...WHEN

SI <EXPRESSION CONDITIONNELLE>  VAUT EXPRESSION 1 ALORS EXPRESSION RESULTANTE 1  VAUT EXPRESSION 2 ALORS EXPRESSION RESULTANTE 2  ...  VAUT EXPRESSION N ALORS EXPRESSION RESULTANTE N SINON EXPRESSION RESULTANTE FIN SI
ce qui se traduit en ruby par :
case <EXPRESSION CONDITIONNELLE>  when EXPRESSION 1 then EXPRESSION RESULTANTE 1 [ when EXPRESSION 2 then EXPRESSION RESULTANTE 2  ...  when EXPRESSION N then EXPRESSION RESULTANTE N else EXPRESSION RESULTANTE] end
case va comparer l'expression le suivant avec les expressions passées après les mots-clefs when. Si l'une d'elle correspond, case appelera l'expression suivant le then. Sinon il évaluera l'expression suivant le else :
À noter que l'expression suivant le case est facultative :
Si age avait été supérieur à 100, c'est la condition else qui aurait été prise en compte.
À noter que then peut être remplacé par le caractère deux points ( : ), on peut également mettre la clause when sur deux lignes :

## Les boucles

Les boucles permettent de parcourir une liste d'éléments, ou d'effectuer une action tant qu'une condition est respectée.

### While/Until

TANT QUE <EXPRESSION CONDITIONNELLE> FAIRE
 EXPRESSION1 FIN TANT QUE
ce qui se traduit en ruby par
while <EXPRESSION CONDITIONNELLE>
 EXPRESSION1 end
Par exemple :
Dans cet exemple l'expression conditionnelle est évaluée avant l'évaluation du corps de la boucle, donc si i avait été égal à 6, le contenu de la boucle n'aurait jamais été évalué. Néanmoins nous pouvons utiliser une autre construction commençant par un bloc et suivit de while, dans ce cas là le corps de la boucle est évalué au moins une fois :
La négation de while est until, que l'on pourrait traduire par "jusqu'à" :

### loop

loop ressemble à la structure while, mais ne prend pas d'expression conditionnelle. En fait loop correspond à
Le seul moyen de quitter la boucle est d'utiliser l'instruction break :

### For in

La boucle for permet d'itérer à travers un ensemble :
Nous verrons les intervalles (de forme x..y) dans le chapitre suivant, pour l'heure il suffit de savoir qu'ils représentent tous les éléments compris entre x et y.
Ceci est une manière d'itérer, néanmoins nous verrons dans les chapitres suivant qu'en ruby il vaut mieux itérer en utilisant les méthodes adaptées. Ainsi le même exemple aurait pu s'écrire :
Pour les chaînes de caractères, le retour chariot servira de séparateur :

## Itérateurs

un grand nombre d'objet en Ruby implémente des itérateurs, cad; des méthodes de parcours des éléments de l'objet lui-même.

### each

La boucle each (chaque en anglais) parcours tous les éléments d'un tableau en assignant à une variable temporaire l'élément actuel.
Soit dans une classe la va

### each_byte et each_line

Les chaînes de caractères ont une méthode spécifique appelée each_byte (chaque caractère) qui parcours la chaîne caractère par caractère :
Et each_line (chaque ligne) qui parcoure les lignes séparés par le retour chariot :

### times

Fonction typique à Ruby, la méthode d'itération des classes d'entiers nommée times (fois) et qui peut être utilisé avec les constantes numériques (ce langage étant pur objet) :
ou bien :

## Les mots clés de contrôle d'execution

Parmi les rares mots clés du langage, on trouve un certain nombre de controles d'execution

### Break

Nous avons déjà vu break qui permet d'interrompre l'exécution d'une boucle :

### Redo

redo va réévaluer le corps de la boucle, mais sans retester la condition, et sans utiliser l'élément suivant (dans un itérateur)
La variable i étant définie localement (dans la boucle), cela ne change pas le déroulement par rapport à la liste globale, mais la variable est bien vue comme ayant une valeur différente de 2 la seconde fois et le redo est évité. Le puts suivant le redo dans le bloc de code de la boucle n'est pas exécuté lorsque celui est exécuté.

### Next

next va aller à la fin de la boucle, puis recommencer l'itération avec l'élément suivant dans le cas d'un itérateur :

### Retry

retry recommence l'itération à son début, dans son état premier :
On entre ici dans une boucle infinie.

## Remarques
### Boucles implicites

Le parcours des éléments d'un tableau dans Ruby est implicite lorsque on l'utilise comme variable d'assignation, comme c'est le cas pour les chaînes de caractère dans la majorité des langages :
On peut de la même façon extraire une partie d'un tableau simplement sans avoir à créer de boucle qui parcoure tous les éléments.
Exemple tiré du site officiel de Ruby
Cet exemple sort les éléments du tableau qui sont dans les villes mais pas dans visitées

# 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).

# Classes
## 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 ]
En programmation objet ou orienté objet, une classe est un modèle d'objet constitué d'attributs (ses variables et constantes), de méthodes (ses fonctions), ainsi que des contraintes d'accès. Les méthodes et attributs peuvent être plus ou moins accessibles aux autres classes ou au programme principal.
En Ruby, par défaut, les attributs ne sont pas accessibles.

## Déclaration d'une classe

Une classe est déclarée à l'aide du mot-clé class et se termine par le mot-clé end Les définition de classe étant des constantes, leurs noms doivent commencer par une majuscule en Ruby. Une classe a au minimum une méthode dite constructeur qui sert à initialiser les objets créés par l'opérateur new. En Ruby le constructeur est nommé initialize. Les méthodes sont définies à l'aide du mot-clé def et se terminent par le mot-clé end
En Ruby, les variables commençant par @ sont des attributs d'objet, les autres sont des variables locales. @x est donc différent de x et @y est différent de y.
Dans cette méthode initialize, on a donné des valeurs par défaut aux paramètres (x=0, y=0), cela permet de créer des instances de cette classe sans préciser la valeur des arguments.

## Instanciation

Une instance de la classe (un objet) est créé par la méthode new de la classe :
Ici les valeurs par défaut (0,0) seront utilisées
On peut passer des valeurs à la méthode d'initialisation entre parenthèses :
On peut obtenir le type de la classe grâce à la méthode class :

# Méthodes
## 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 ]
En programmation objet, les méthodes sont les fonctions appartenant à une classe. En réalité, elles sont des messages envoyé à un objet.
En Ruby, elles sont définies de la façon suivante :

### Les arguments

Les arguments de la méthode forment une liste de références d'objets.
Ils peuvent être fournis de façon unique ou en liste via :

### Les blocs liés

Une méthode Ruby peut recevoir en paramètre la référence à un bloc de code tel que :
Si en dernier paramètre de méthode, en prototype, on trouve une déclaration explicite avec une esperluette, alors le bloc est converti en objet Proc et cet objet entre dans la liste de paramètres de la méthode :

## le constructeur initialize

La méthode initialize, par exemple, est la méthode appelée lorsqu'une instance est créée via la méthode new :
Ici la méthode initialize définie les variable d'instances @x et @y en fonction des paramètres passés à la fonction new.
Si par exemple on initialise un objet comme suit :

## Valeurs par défaut

On peut en Ruby donner des valeurs par défaut aux arguments des méthodes.
Si l'on appelle la méthode sans argument, la valeur par défaut est assigné à la variable d'instance @qui
Si l'on appelle la méthode avec un argument, celui-ci remplacera la valeur par défaut :

# Accesseurs
## 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 ]

## Les accesseurs

Un accesseur est une méthode d'accès à un attribut.
Il existe deux type d'accesseurs :
* accesseurs en lecture (Get dans certains langages)
* accesseurs en écriture (Set dans certains langages)
En Ruby c'est une méthode qui porte le nom de l'attribut en lecture et le nom de l'attribut suivit de '=' en écriture tel que :
Ruby propose des macro-constructions d'accesseurs pour simplifier l'écriture des classes :

# Héritage
## 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 ]
L'héritage permet de créer une classe à partir d'une autre pour l'enrichir, ou la spécialiser. Une classe (classe dérivée, ou classe fille) hérite d'une autre classe (classe de base, ou classe mère).
On peut toujours utiliser les méthodes de la (des) classe(s) mère(s) dans une classe dérivée.
L'opérateur < précède le nom de la classe de base.

## Exemple

La classe Point vue précédemment :
peut être dérivée en une classe PointCouleur représentant un point coloré. Cette classe possède donc un attribut supplémentaire pour la couleur :
Lorsqu'on crée une instance de la classe dérivée, on bénéficie immédiatement des méthodes de celle-ci :
Et les méthodes de la classe de base étant héritées, on pourra la réutiliser dans la classe dérivée :
Par contre, la classe de base ne possède pas les méthodes définies dans les classes dérivées.

# stdlib
## 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 ]
Ruby est livré avec une bibliothèque standard. Elle propose plusieurs classes dont, notamment :
* time
* erb
* uri
Ces classes sont utilisées à d'autres points du livre. Pour les autres, vous pouvez vous référer à la documentation de la bibliothèque standard.

# Ruby et le texte non structuré
## 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 ]

## Analyser du texte

L'implémentation des réseaux baysiens en Ruby est bn4f (Bayesian Networks for Ruby)
On peut pratiquer une analyse sémantique latente grâce à classifier qui fournit aussi des réseaux bayésiens.

## Indexer du texte

Lucene est porté en Ruby sous le nom de Ferret.

# Programmation concurrente

Ruby intègre nativement la notion de processus et de processus léger.

## Utiliser des processus légers

Les processus légers sont représentés par la classe Thread. À la construction du thread, on passe un bloc qui sera exécuté.

## Synchroniser des données

Dans l'exemple ci-dessus, la variable i est partagée. Cela peut poser un problème de synchronisation. Pour le résoudre, on utilise un sémaphore. Pour qu'un objet soit synchronisé, il faut lui ajouter un attribut Mutex.

## Arrêter un thread

Pour arrêter un thread proprement, on affecte son attribut @continue à faux (par exemple dans une méthode #stop).
On peut arrêter un thread de façon brutale avec un appel à Thread#terminate.

# Programmation distribuée
## 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 ]
Cette page est considérée comme une ébauche à compléter . Si vous possédez quelques connaissances sur le sujet, vous pouvez les partager en éditant dès à présent cette page (en cliquant sur le lien « »).
Ressources suggérées : Aucune (vous pouvez indiquer les ressources que vous suggérez qui pourraient aider d'autres personnes à compléter cette page dans le paramètre « ressources » du modèle engendrant ce cadre)
Ruby intègre nativement le module DRb qui contient Rinda.

# Persistance des données
## 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 ]

## Mémoriser des données dans la RAM

Elles seront ainsi disponibles entre deux exécutions d'un programme. Madeleine peut donc mémoriser des objets dès lors qu'ils sont sérialisables avec Marshal.

## YAML

YAML (YAML Ain't Markup Language) permet de sérialiser des objets et de collection d'objets. Tout comme XML, c'est un format lisible par l'humain. On peut ainsi modifier directement un fichier yaml via un éditeur de texte.
YAML est souvent préféré à XML dans la communauté Ruby qui juge ce dernier trop verbeux.
Ruby permet de manipuler des le format YAML via yaml4r.

## Manipuler du XML
# Web
## 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 ]
Ruby permet d'interagir avec le Web en tant que client mais aussi en tant que serveur.

## Créer des applications Web

Ruby propose, entre autre :
* RoR :le célèbre framework MVC Ruby on Rails, pour des besoins plutôt applicatifs.
** RoR s'appuie sur ActiveRecord pour la partie Modèle, les suites de composants Action.* et Active.* pour les controlleurs et les vues.
* Merb : un autre framework MVC voulu plus souple et modulaire, pour une approche plus adaptable.
* Sinatra : un framework minimaliste, léger et terriblement efficace, pour des besoins limités et spécifiques.

## Web scraping en Ruby

Il est possible de faire du Web-scraping en Ruby via la bibliothèque net/http. Cela est toutefois rudimentaire et on préfèrera utiliser un framework tel scRUBYt!.

# Réflexion
## 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 ]

## Méthodes de l'instance

La méthode générique, présente dans toutes les classes, instance_methods renvoie la liste des méthodes existantes.
Cette liste contient l'ensemble des méthodes existant par défaut, plus celle qui ont été créées.
On peut obtenir une liste restreinte aux fonctions que l'on a créées en remplaçant l'argument true (vrai, valeur par défaut) par false (faux) :
Au contraire, on peut obtenir les méthodes qui ne sont pas que des méthodes d'instances :

### Classe de l'instance

La méthode type permet de connaître le type (donc la classe) utilisé par l'instance :

## Existence d'une méthode

On peut déterminer si une méthode existe ou pas à l'aide des méthodes par défaut :
On peut également déterminer si elle est publique (accessible en dehors de la classe) :

## Manipuler des contextes

L'objet Binding que l'on peut obtenir grâce à Kernel#binding.

# Exemples de code

Tous ces exemples peuvent être testés directement dans irb. Il existe une version web d'irb pour tester Ruby dans un navigateur : TryRuby.

## Objets

Les nombres sont des objets. Pour obtenir la valeur absolue de -12 :
La taille d'une chaîne de caractères :
Trier un tableau et l'inverser :
Table de hachage :

## Blocs et itérateurs

Saluer 10 fois :
Afficher le carré de chaque nombre d'un tableau :
Obtenir un tableau contenant la racine carrée de quelques nombres :
Trier des chaines de caractères en fonction de leur taille :

## Structures

Création d'une structure Livre :

## Classes

* Création d'une classe Bibliotheque qui stocke des livres
* Création de la bibliothèque
et lancez le script avec ruby.

# Tests unitaires
## 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 ]
Cette page est considérée comme une ébauche à compléter . Si vous possédez quelques connaissances sur le sujet, vous pouvez les partager en éditant dès à présent cette page (en cliquant sur le lien « »).
Ressources suggérées : Aucune (vous pouvez indiquer les ressources que vous suggérez qui pourraient aider d'autres personnes à compléter cette page dans le paramètre « ressources » du modèle engendrant ce cadre)
La bibliothèque standard intègre Test::Unit qui permet de réaliser des tests unitaires.

# Rdoc
## 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 ]
Cette page est considérée comme une ébauche à compléter . Si vous possédez quelques connaissances sur le sujet, vous pouvez les partager en éditant dès à présent cette page (en cliquant sur le lien « »).
Ressources suggérées : Aucune (vous pouvez indiquer les ressources que vous suggérez qui pourraient aider d'autres personnes à compléter cette page dans le paramètre « ressources » du modèle engendrant ce cadre)
La plate-forme Ruby propose l'outil Rdoc.

# Étendre Ruby
## 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 ]
Cette page est considérée comme une ébauche à compléter . Si vous possédez quelques connaissances sur le sujet, vous pouvez les partager en éditant dès à présent cette page (en cliquant sur le lien « »).
Ressources suggérées : Aucune (vous pouvez indiquer les ressources que vous suggérez qui pourraient aider d'autres personnes à compléter cette page dans le paramètre « ressources » du modèle engendrant ce cadre)

## Faire appel à des bibliothèques Java depuis JRuby

Cela est rendu possible par l'implémentation JRuby de Ruby.

# Mots Réservés
## 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 ]

# variables globales prédéfinies
## 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 ]

## Variables globales

| Nom | Type | Description |
| __FILE__ | String | Représente le fichier courant |
| __LINE__ | Fixnum | Représente la ligne courante |
| $! | String | Dernier message d'erreur |
| $' | Object | description |
| $" | Object | description |
| $$ | Object | Retourne le numéro de process du programme |
| $& | Object | description |
| $* | Object | Liste des arguments passés au script |
| $+ | Object | description |
| $, | Object | description |
| $-0 | Object | Nom du script en cours d'exécution |
| $-F | Object | description |
| $-I | Object | description |
| $-K | Object | description |
| $-a | Object | description |
| $-d | Object | description |
| $-i | Object | description |
| $-l | Object | description |
| $-p | Object | description |
| $-v | Object | description |
| $-w | Object | description |
| $. | Object | Numéro de la dernière ligne lue par l'interpréteur |
| $/ | Object | description |
| $: | Array | Alias de $LOAD_PATH |
| $; | Object | description |
| $< | Object | description |
| $= | Object | description |
| $> | IO | Alias de STDOUT / $stdout |
| $? | Object | Valeur de la sortie du dernier sous-processus exécuté |
| $@ | String | Contexte de la dernière erreur |
| $\ | Object | description |
| $_ | Object | Dernière chaîne de caractère donnée par gets |
| $` | Object | description |
| $~ | MatchData | Dernière Regexp évaluée |
| $1 à $9 | Object | description |
| $0 | String | Chemin du script en cours d'exécution |
| $configure_args | Object | description |
| $DEBUG | Object | description |
| $deferr | Object | description |
| $defout | Object | description |
| $expect_verbose | Object | description |
| $F | Object | description |
| $FILENAME | Object | description |
| $KCODE | Object | description |
| $LOAD_PATH | Array | Emplacements de recherche des libs pour require |
| $SAFE | Fixnum | Niveau de sécurité |
| $stderr | IO | Représente la sortie d'erreur standard |
| $stdin | IO | Représente l'entrée standard |
| $stdout | IO | Représente la sortie standard |
| $VERBOSE | Object | description |

## Constantes globales

| Nom | Type | Description |
| DATA | File | Données placées en fin de script avec le mot clé __END__ |
| FALSE | FalseClass | faux |
| NIL | NilClass | correspond à null (rien) |
| RUBY_PLATFORM | String | Indique la plateforme courante |
| RUBY_RELEASE_DATE | String | Date de la distribution de la version courante |
| RUBY_VERSION | String | Le numéro de version |
| STDERR | IO | La sortie d'erreur standard |
| STDIN | IO | L'entrée standard |
| STDOUT | IO | La sortie standard |
| SCRIPT_LINES__ | Object | description |
| TOPLEVEL_BINDING | Object | description |
| TRUE | TrueClass | vrai |

# Caractères d'échappements
## 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 ]
Le tableau suivant liste des caractères d'échappement utilisables dans les chaînes de caractères.
| Nom | Description |
| \a | Sonnerie |
| \b | Efface le caractère précédent |
| \e | Efface le caractère suivant |
| \n | Nouvelle ligne |
| \r | Retour en début de ligne |
| \s | Espace |
| \t | Tabulation horizontale |
| \v | Tabulation verticale |
| \nnn | Caractère dont le code ASCII est donné en octal nnn |
| \xnn | Caractère dont le code ASCII est donné en hexadécimal nn |
| \C-x | Control-x |
| \M-x | Meta-x |
| \M-\C-x | Meta-control-x |

# 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

## 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 ]
* Le site officiel du langage Ruby :
    http://www.ruby-lang.org
* Le site de la documentation Ruby :
    http://www.ruby-doc.org
* Le site regroupant la plupart des modules Ruby (équivalent du cpan de perl) :
    http://raa.ruby-lang.org/
* Le site regroupant la plupart des projets écrits en Ruby :
    http://rubyforge.org/
* Demandes de changement à Ruby :
    http://rcrchive.net/
* News, discussions... autour de Ruby :
    http://www.rubygarden.org/
* Rubygems : le gestionnaire de package pour ruby :
    http://rubyforge.org/projects/rubygems/
* Pleac : Exemples de code en Ruby :
    http://pleac.sourceforge.net/pleac_ruby/index.html
* Apprendre à programmer : un manuel d'apprentissage de la programmation basé sur Ruby :
    http://www.ruby-doc.org/docs/ApprendreProgrammer/Apprendre_%E0_Programmer.pdf
* Tutoriel complet Ruby on Rails :
    http://www.meshplex.org/wiki/Ruby/Ruby_on_Rails_programming_tutorials