Souvent, on souhaite écrire une méthode calculant une valeur donnée, et qui
la retourne. On appelle fonctions ces méthodes qui renvoient un
résultat.Écrire une fonction n'est pas tellement plus dur que pour les
méthodes sans résultat.
[!java|c]Il suffit d'écrire le type de données renvoyées par votre fonction
avant son nom (là où nous écrivions void
avant).[/!]
[!scala]Il suffit d'ajouter deux points (:), le type de données renvoyées
par votre fonction et le signe égal (=) entre les parenthèses de la
déclaration et l'accolade du bloc. Cette syntaxe est assez proche de la
définition d'une variable (avec son type) dont la valeur serait une
fonction.[/!]
Vous pouvez utiliser l'instruction return
n'importe ou dans le
corps de votre fonction pour spécifier que le calcul est fini (la suite de
la fonction n'est pas exécutée) et donner la valeur à donner à l'appelant
après le mot-clé return
.
[!java|c]double pi() {[/!][!scala]def pi(): Double = {[/!][!python]def pi():[/!] return 3.14159[!java|c];[/!] [!java|scala|c]}[/!]
En fait, vous pouvez également utiliser le mot-clé return
dans
les méthodes ne renvoyant pas de résultat, pour interrompre leur
exécution. Dans ce cas, il ne faut bien entendu pas donner de valeur à
droite du return
.
Il est possible d'avoir plusieurs instructions return
dans
différentes branches de if
. Ce qui est interdit, c'est d'avoir
une branche du code qui n'est pas terminée par un return
, ou
d'écrire du code après le return
.
En effet, si la machine arrive à la fin de la fonction sans avoir rencontré
de return, elle ne peut pas savoir quelle valeur communiquer à
celui qui a appelé la fonction. De plus, le return interrompt
immédiatement l'exécution de la fonction (pourquoi continuer à chercher
quand on a déjà trouvé le résultat de la fonction?). Donc, s'il y a du code
après un return, c'est sans doute une erreur, et le compilateur
vous l'indique.
[!java|scala|c][!java][!java]boolean [/!][!c]int [/!] [/!][!scala]def [/!]estDevantLibre()[!scala]:Boolean =[/!] { if (estFaceMur() == [!java|scala]true[/!][!c]1[/!]) { return [!java|scala]false[/!][!c]0[/!]; /* interdit d'écrire du code ici */ } else { return [!java|scala]true[/!][!c]1[/!]; /* pareil ici */ } /* même ici, oubliez */ }[/!][!python]def estDevantLibre(): if estFaceMur() == True: return False # interdit d'écrire du code ici else return True # pareil ici # même ici, oubliez[/!]
haveBaggle
, et elle doit renvoyer un
booléen indiquant si la colonne face à la buggle contient un biscuit ou
non. Votre buggle va s'en servir pour chercher la première colonne contenant
un biscuit et s'y arrêter.
Le plus simple pour écrire cette fonction est peut être d'utiliser une
variable booléenne vuBiscuit
indiquant si on a vu un biscuit
jusque là. Initialement, elle contient faux
(«[!python]False[!/][!scala|java]false[/!][!c]0[/!]»).
Ensuite, on avance de 6 cases (le monde contient 7 cases, et on est déjà sur l'une d'entre elles). Pour chaque case, si elle contient un biscuit, on range la valeur vrai dans vuBiscuit (et on ne fait rien d'autre qu'avancer si non).
Quand on est arrivé à la fin, on recule de 6 cases, et on retourne le contenu de vuBiscuit à l'appelant.
Cet exercice est un peu particulier, puisqu'il a deux mondes initiaux, chacun ayant un objectif particulier. Votre code doit fonctionner pour chacun d'entre eux. Remarquez que le menu déroulant de sélection du monde (juste sous la barre de réglage de la vitesse) permet de spécifier le monde que vous souhaitez observer.
Quand votre fonction haveBaggle fonctionne, passez à l'exercice suivant.