# Programmation Ruby/Contrôle
## 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 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