# Programmation Ruby/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 :