Les méthodes

1 . Introduction

Dans ce tutoriel, nous allons aborder les **méthodes**. Qu'est-ce qu'une méthode ? La méthode est un ensemble d'**instructions** qui va nous permettre de réaliser quelque chose : par exemple additionner, soustraire, etc. ``print`` par exemple, est une méthode permettant d'afficher du contenu. Une méthode est **réutilisable** tant qu'on le souhaite : au lieu de réécrire plusieurs fois le même code pour faire la même action, on va tout simplement créer une méthode et la rappeler à chaque fois qu'on en aura besoin.

2 . Méthode à 1 argument

Reprenons notre exemple de méthode ``hello`` : ``` def hello(firstname) puts "Bonjour #{firstname} !" end hello("Paul") ``` On a donc l'argument firstname à notre méthode hello. On lui dit d'écrire "Bonjour *firstname* !" lorsqu'elle sera appelée. Et enfin on l'appelle avec "Paul" comme argument et on obtient le résultat suivant : ``Bonjour Paul !`` Si on oublie l'argument lors de l'appel de la fonction : ``` def hello(firstname) puts "Bonjour #{firstname} !" end hello #ou print hello ``` Cela affichera un message d'erreur : 

3 . Déclarer une méthode

Nous allons apprendre à déclarer une méthode dans Ruby. Il faut savoir qu'une méthode commence toujours par ``def`` et se termine par ``end``. ``` def hello #définition de la methode, ici elle s'appelle hello print "coucou toi !" #ici l'instruction demande à afficher "coucou toi !" quand la méthode est appelée end hello #ici on appelle la méthode ``` La méthode ``hello`` va bien nous retourner "coucou toi !".

4 . Méthode à plusieurs arguments

Les méthodes à plusieurs arguments ne sont pas plus compliquées à écrire. Reprenons notre exemple d'addition : nous avions 2 arguments ``a`` et ``b``. Et bien ça tombe bien, regardez comment on va l'écrire : ``` def addition(a,b) return a + b end print addition(10,15) #on entre les valeurs que l'on souhaite pour a et b qui nous seront retournées ``` et on obtient bien le résultat suivant : ``25``.

5 . Valeur de retour

La méthode que nous avons vu précédemment n'a servi qu'à afficher une simple phrase. Nous allons voir dans cette section comment faire une méthode qui va nous retourner le résultat d'une addition : ``` def addition #définition de la méthode, ici addition a = 10 b = 15 return a + b # va retourner le résultat de l'addition. end print addition #sans le print de l'addition, la méthode ne va rien afficher à son exécution ``` Le ``return`` n'est pas obligatoire, vous pouvez tout aussi bien écrire la méthode de cette façon : ``` def addition a = 10 b = 15 a + b end print addition ``` ``return`` est cependant très pratique puisqu'il met fin à la méthode. Toute instruction qui se situe après sera ignorée : ``` def addition a = 10 b = 15 return a + b print "coucou" end print addition ``` En exécutant la méthode, seulement le résultat de l'addition est affiché : ``25``. Le ``print "coucou"`` est bien ignorée.

6 . Les valeurs par défaut

Comme nous avons pu le voir dans un exemple précédent, il est possible d'avoir un message d'erreur lorsque l'argument n'est pas rappelé. Cependant, il est possible d'assigner à notre/nos argument(s) une valeur par défaut qui évitera l'affichage de ce type d'erreur. Reprenons notre exemple de méthode ``hello`` avec le prénom de la personne comme argument : ``` def hello(firstname = "Paul") puts "Bonjour #{firstname} !" end hello("Denis") hello ``` En donnant la valeur par défaut ``Paul`` à ``firstname``, quand nous appelons ``hello`` sans parathèse ni argument, cela ne nous retourne plus de message d'erreur mais simplement "Bonjour Paul !". Et quand on appelle ``hello("Denis")``, ça nous affiche bien "Bonjour Denis !" et non pas Paul.

7 . Les arguments

Les arguments sont des paramètres qui vont influencer l’exécution de la méthode. Ils vont s'écrire entre ``()`` après le nom de notre méthode : ``` def hello(firstname) end ``` Pour reprendre l'exemple des méthodes ``print`` et ``puts``, elles prennent chacune en argument des données à afficher. Les données affichées ensuite sont différentes en fonction des données renseignées.