Apprendre a scripter partie |(1) chapitre |||(3)

Voici donc le troisieme chapitre pour apprendre le ruby.

Je repete que je ne connais pas le ruby mais je suis tombé desus en apprenands le php.

Ce tutoriel est de Loktar.

Chapitre 3]
Les bases du langage
* Structure d'un programme
* Stockage des données
* Instructions de contrôle

Les principaux atouts du langage ont déjà été énoncés, voyons maintenant certaines de ses caractéristiques plus profondes.

NDLR : Ce chapitre est l'un des plus importants (sauf si vous avez déjà les bases), si vous trouvez qu'il n'est pas assez détaillé, qu'il est trop "compact" ou d'une manière générale trop difficile ou désagéable à lire, n'hésitez pas à le signaler !

---------------------------------------------------------------------------------------------------------------

Structure d'un programme
Les délimiteurs d'instruction


En Ruby, les instructions peuvent être regroupées en bloc. Ces blocs sont liés à une boucle, une condition, etc. Ils sont le plus souvent délimités par des accolades (comme dans la majorité des langages de programmation de haut niveau). Il est néanmoins possible de remplacer l'accolade fermante } par le mot-clé end, dans certans cas, l'accolade ouvrante { doit être remplacée par do, dans d'autres, un mot-clé (comme if) suffit, comme en témoigne cet exemple :

Code:

condition {
instructions
}

équivaut à :

Code:

condition
  instructions
end

En général, la deuxième solution est plus appropriée, sauf si vous êtes omnibulé par le gain de place dans votre code source (pour faire tenir votre bloc sur une seule ligne, les accolades sont plus pratiques, mais c'est déconseillé ).

Les instructions du programme sont usuellement séparées par un point virgule (situé en fin de ligne). Ruby (contrairement à certains autres langages) vous permet d'omettre ce point virgule si vous vous limitez à une seule instruction par ligne. Nous utiliserons cette particularité dans tout le tutoriel.
Stockage des données
Les variables


Une donnée peut être associée à un mot la caractérisant. Ce mot est appelé variable. Lorsque vous vous apprêtez à utiliser une variable, vous devez l'initialiser, c'est à dire lui associer une valeur (un chiffre, une chaîne de caractères, etc.), sans quoi elle sera verra assigner la valeur nil (null dans d'autres langages, absence de valeur) par défaut (sauf pour les variables locales). Voici un exemple :

Code:

nom = "Aristote"
annee = "2006" #surtout pas de caractère accentué dans un nom de variable
langage = "Ruby"
repetitions = 2
puts (nom + " apprend le " + langage + " en " + annee) * repetitions
puts "#{nom} apprend le #{langage} en #{annee}" * repetitions

Une variable ne doit surtout pas débuter par un chiffre !


Ce code produit :

Code:

Aristote apprend le Ruby en 2006Aristote apprend le Ruby en 2006
Aristote apprend le Ruby en 2006Aristote apprend le Ruby en 2006

En effet #{variable} est remplacé (lorsqu'il est placé entre guillemets) par la valeur de la variable en question, ici #{nom} est remplacé par "Aristote".

Récupérer une saisie au clavier


puts et print que nous avons déjà rencontrées plus tôt sont des méthodes capables d'afficher une chaîne de caractères sur la sortie standart (console).


Pour effectuer l'opération inverse, c'est-à-dire saisir une chaîne de caractères sur l'entrée standart (lorsque vous tapez quelque chose au clavier), utilisez la méthode gets et placez ce qu'elle reçoit dans une variable :

Code:

puts "votre nom ?"
nom = gets
puts "votre nom est #{nom}"

Les flux d'entrées et de sorties seront vus plus en détails par la suite

Fermons cette parenthèse et revenons à nos variables : par définition, la valeur d'une variable peut varier au court du programme, il en existe 4 types.

Les variables globales


Les variables globales sont des variables dont la valeur est accessible n'importe où dans le programme. Leur nom commence par le symbole $. Il existe quelques variables globales dont le nom est réservé, dont en voici quelques unes (utiles pour suivre le cheminement d'un script ou pour localiser des erreurs) :

* $_ désigne la dernière chaîne lue par gets
* $@ désigne le lieu de l'erreur (le cas échéant)
* $. désigne la dernière ligne lue par l'interpréteur
* $* désigne les arguments de la ligne de commande


Les variables locales


Un nom de variable locale débute par une lettre minuscule (comme toutes les variables que nous avons utilisées dans nos exemples jusque là) ou par un tiret underscore : _
Par défaut, les variables sont locales, elles sont théoriquement accessibles partout dans le programme, mais contrairement aux variables globales, elles ne possèdent pas la valeur nil avant initialisation.

Si vous ne savez pas quel type de variable utiliser, et que vous voulez faire les choses rapidement et simplement, utilisez une variable locale.


Les variables d'instance


Les variables d'instance commencent par le symbole @. Ces variables ne sont accessibles que depuis une classe. Il est aussi à noter que deux objets de la même classe peuvent avoir des mêmes variables d'instance mais dont la valeur diffère. Elles sont donc spécifiques à une instance d'une classe donnée.

Les variables de classe


Ces variables contiennent une information stockée dans la classe elle-même et non dans les objets instanciés par cette classe, en outre cette information s'applique à toutes les instances créées par cette classe. Ces variables commencent par @@.

Les constantes


Les constantes remplissent la même fonction que les variables, à la seule différence que vous ne devez pas modifier leur valeur le long du programme. Si vous le faites, vous n'obtiendrez pas d'erreur, mais un simple avertissement. Le nom d'une constante débute par une majuscule, vous pouvez également les écrire intégralement en majuscule, pour les repérer plus facilement.
Un petit exemple pour récapituler :

Code:

class Chameau
  @@nombre_pattes = 4 # variable de classe
  @@nombre_bosses = 2 # idem
  RACE = "chameau" # constante de classe, non précédée de @@
  def marcher
    puts "..."
    $sensation = "fatigue" # variable globale
  end
  def boire(l)
    litres = l # variable locale
    BOISSON = "eau" # constante
  end
  def appeler(nom)
    @nom = nom # variable d'instance
  end
end

Les tableaux


Un tableau est une structure pouvant stocker des données. Des données de types différents peuvent cohabiter dans un même tableau (par exemple, un nombre quelconque et une chaîne de caractères). Un tableau est délimité par des crochets et les différents éléments dont il est constitué sont séparés par des virgules.

Chaque élément du tableau est associé à un chiffre (un entier naturel pour être exact ) qui représente la case du tableau qu'il occupe, la première case porte le numéro 0. Un exemple pour vous éclairer :

prix = [30, 400, 25, 73] # création d'un tableau quelconque contenant des entiers
puts prix # affichage de toutes les valeurs du tableau
langues = ["fr", "en", "ruby"] # un tableau de chaînes de caractères
puts langues # que l'on affiche


et on obtient :

Code:

30
400
25
73
fr
en
ruby

Les hachages


Les hachages sont des tableaux particuliers, au lieu d'associer une valeur à la place qu'elle occupe dans le tableau, elle sera associée à une clé (un autre mot ). Voilà qui devrait vous parler davantage :

Code:

livre = {
    "titre"  => "Toto perd la tête",
    "auteur"  => "Toto",
    "sujet"  => "La vie de Toto"
}

Dans cet exemple, "Toto" est associé à la clé "auteur", cette valeur est désignée par livre["auteur"].

Si on avait eu recours à un tableau, on aurait utilisé livre[2] pour désigner "Toto". La seconde différence essentielle avec les tableaux ordinaires est l'utilisation d'accolades dans la déclaration des éléments à la place de crochets. Vérifiez que vous ne vous êtes pas trompés en cas d'erreur inexpliquée ^^ .

Quand utiliser un hachage plutôt qu'un tableau ?

Lorsque les données sont du mêmes type, et qu'elles appartiennent à un même ensemble (par exemple : la suite des nombres premiers jusqu'à 1000, la liste des prénoms de vos amis, etc.) un tableau est plus indiqué. Dans tous les autres cas, un hachage devrait convenir davantage. Tout dépend de ce que vous estimez être le plus pratique en fonction de vos besoins.
Instructions de contrôle
Les conditions


Sans les conditions, les programmes seraient monotones, linéaires, ils fonctionneraient toujours de la même façon. Or, dans la plupart des cas, on a besoin d'adapter le déroulement du programme en fonction de certains paramètres (le plus souvent, une action de l'utilisateur), voilà pourquoi les programmeurs ont recours aux structures conditionnelles.

if - else


La structure en if - else est la plus simple des structures conditionnelles. Elle évalue une expression, si (if) cette condition est remplie, certaines instructions sont exécutées, sinon (else) on en exécute d'autres. Comme l'illustre cet exemple :

Code:

age = 17
if age >= 18
  puts "vous etes majeur"
else
  puts "vous etes mineur"
end

Vous pouvez modifier la valeur de age pour voir le résultat obtenu. Afin de tester ce genre d'expression arithmétique, vous disposez des opérateurs suivants :

* == vérifie l'égalité de premier terme par rapport au second (à ne pas confondre avec le symbole d'égalité simple qui sert à l'affectation de valeurs)
* < vérifie que le premier terme est strictement inférieur au second
* > vérifie que le premier terme est strictement supérieur au second
* <= vérifie que le premier terme est inférieur ou égal au second
* >= vérifie que le premier terme est supérieur ou égal au second
* != vérifie l'inégalité du premier terme par rapport au second


Une structure conditionnelle se termine par le mot-clé end. Mais celui ci se situe après la dernière condition (ici après le else, et non après le if)

Si une condition est vérifiée, l'état true (vrai(e)) lui est assigné, le cas échéant, ce sera la valeur false. Ces deux mots-clés sont ce qu'on appelle des valeurs booléennes, vous pouvez aussi les assigner à des variables.

Code:

estMajeur = false
if (estMajeur)
  puts "Vous etes majeur"
else
  puts "Vous etes mineur"
end

La valeur true se déduit d'elle même, vous n'avez pas besoin d'écrire if (estMajeur == true). Pour tester la valeur false, on aurait pu écrire if (estMajeur == false), mais ceci fonctionne aussi : if !(estMajeur).

else if / elsif


La condition vue précédemment peut être enrichie davantage, des choix intermédiaires peuvent être proposés, par test de plusieurs conditions successives (si.. sinon si.. sinon si.. sinon). La première condition vérifiée comme étant vraie sera exécutée, les autres seront alors ignorées (même si elles sont vraies elles aussi).

Code:

a = 5
b = 4
c = 7
if (a < b) # la condition est fausse
  #instruction quelconque
else if (a < c) # la condition est vraie
  #instruction quelconque
elsif (b < c)  # la notation elsif équivaut à else if
                # la condition est vraie mais ne sera pas considérée comme true
                # les instructions qui la suivent ne seront pas exécutées
  #instruction quelconque
else
  #instruction quelconque
end

Les remarques faites précédemment sont encore valables ici.

unless


unless est la condition contraire de if. Elle exécute une instruction sauf si la condition est vérifiée. Par exemple :

Code:

unless 1>3 # condition fausse
        puts "yes"  # on exécute
end

unless (estMajeur) effectue la même chose que if !(estMajeur), vous pouvez donc utiliser la condition que vous préférez. :p

L'instruction case


Cette instruction teste une suite de conditions : elle évalue plusieurs cas et exécute certaines instructions en conséquence (la première condition vérifiée masque les autres comme dans la structure if - elsif - else). Voici comment l'utiliser :

Code:

z = 4
case z # on teste différents cas en fonction de la valeur de z
when 1 # dans le cas où z = 1
  print "z = 1"
when "maison" # dans le cas ou z contient la chaîne "maison"
  print "z = 'maison'"
when z = 2
when z = 3
when z = 4
  puts "z = 4"
when z = 5
end

Il est également possible de tester si la variable testée appartient à un intervalle donné, nous verrons comment faire ceci lors de l'étude de la boucle for. Cette structure case se termine là aussi par un end.

Les boucles


Les boucles sont utilisées dans l'objectif de répéter une instruction donnée un certain nombre de fois. Là aussi, il existe plusieurs manières d'accomplir la même chose.

La boucle while


La boucle while (tant que) équivaut à un if qui se répète tant qu'une certaine condition est considérée comme true ou tant qu'elle est considérée comme false.

Code:

a =2
b = 5
while (a < b)
  puts "a < b"
end

Ici, la condition est toujours vraie, la boucle se répètera alors à l'infini. Donc dans une boucle while, on modifie la valeur d'une donnée prise en compte dans l'instruction, qui est ici un nombre, mais qui pourrait aussi bien être une valeur booléenne :

Code:

estConnecte = true
while(estConnecte)
  puts "vous etes connecte"
  .. # instructions quelconques
  estConnecte = false # au bout de X exécutions de la boucle
end
puts "vous avez ete deconnecte"

De cette façon, on peut régler l'exécution d'une boucle while en utilisant un compteur et ainsi exécuter une instruction un certain nombre de fois. Voici comment procéder :

Code:

var = 0 # on initialise la variable
while (var <= 14)
  puts var
  var = var + 1 # on augmente sa valeur de 1, sinon la boucle est infinie
end

La boucle loop


La boucle loop est infinie, et ne prend donc pas de condition en paramètre, elle équivaut à une boucle while(true). Etant donné qu'elle est infinie, il vous faudra l'instruction break pour en sortir.

Code:

n = 0
loop {
  puts n
  if (n > 10)
    break # sort de la boucle
  end
  n = n+2
}

La boucle until


La boucle until est à la boucle while ce que unless est à if . Cette boucle ne s'exécute non pas tant que la condition est vraie, mais jusqu'à ce qu'elle soit vraie. Elle est donc totalement équivalente à while !(condition), voici un exemple :

Code:

n = 0
until n>5
  puts n
  n = n+2
end

La boucle for


La boucle for est quelque peu différente de la précédente : elle exécute une instruction donnée pour chaque élément d'un ensemble, par exemple pour obtenir le même résultat que celui fourni par la seconde boucle while étudiée (c'est à dire écrire tous les nombres de l'ensemble [O; 14]) il nous faut écrire :

Code:

for nombre in (0..14)
  puts nombre
end

les instructions (puts nombre) sont exécutées pour chaque élément (désigné par nombre) de l'ensemble défini (ici 0..14).

Petite parenthèse :
La notation t..n désigne les éléments compris dans l'intervalle délimité par t et n où t et n sont des nombres et sont considérés comme étant inclus dans cet intervalle.
La notation t...n désigne le même ensemble, à la différence que la seconde borne de l'ensemble est exclue, donc n n'en fait pas partie.
Ceci est notamment utile pour les chaînes de caractères, si on considère : sdz = "siteduzero", alors puts sdz[0..3] affichera "site", on remarque alors que la chaîne de caractère est rangée dans un tableau (la première lettre porte l'indice 0).

Une boucle for se termine par un end.