Fonctions

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]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[/!]

Objectif de cet exercice

Vous allez encore une fois écrire une fonction qui sera utilisée par la buggle. Son nom doit être 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.