Les fonctions

Les fonctions en F.P.L.

Définition

Une fonction est un bloc, un ensemble d'opération, d'instructions qui peut être utilisé dans le code globale. Ces dernières peuvent être très utile pour éviter la répétition ou encore d'avoir un code plus propre.

La base

En F.P.L, pour définir une fonction on va utiliser l'instruction definir.

Voici un petit format pour vous guider : definir [nom] ( [arguments] ) { [code] }

• definir est l'instruction qui nous permet de définir une fonction.

• nom est le nom de la fonction que l'on souhaite définir.

• ( et ) ouvre puis ferme l'introduction des arguments (on verra cela par la suite).

• { et } ouvre puis ferme le contenu de la fonction, c'est entre ces opérateurs que l'on va mettre le code de la fonction.

• code est le code de la fonction.

Ici, pour ne pas vous perdre je ne vais pas vous ajouter des arguments, donc vous n'êtes pas obligé d'écrire quoi que ce soit entre les parenthèses (ces opérateurs : () ).

En revanche, vous pouvez utiliser le type vide pour dire qu'il n'y a rien.

Exemples

definir mafonction () {
    envoyer "Voici une fonction en F.P.L";
}

definir mafonction (vide) {
    envoyer "Voici une fonction en F.P.L avec vide";
}

definir mafonction () {
    variable entier note -> 20;
    envoyer "J'ai eu" [note] "en math, je suis ultra fier :)";
} 

Les arguments

Définition

Un argument se situe dans une fonction et cela permet de transmettre une valeur à cette dernière. Prenons un exemple, je veux transmettre une note a une fonction qui va ensuite dire sa valeur dans la console, on a besoin d'un argument pour donner cette valeur à cette fonction.

La base

Pour déclarer un argument dans une fonction, cela se déroule entre les parenthèses des la fonction (entre ces opérateurs : () ).

On va utiliser ce format : [type] [nom de l'argument]

Si vous souhaitez donner plusieurs arguments, vous devez séparer avec une virgule (,).

Voici un format dans le cas où on a minimum deux arguments : [type] [nom de l'argument], [type du second argument] [nom second argument], etc.

ATTENTION à ne pas laisser une virgule dans le vide sans rajouter d'argument si vous ne voulez pas en rajouter un autre : (entier a, )

Ici cela donnera une erreur car on attend de vous de rajouter un argument. Si vous ne souhaitez pas rajouter un argument vous devez retirer la virgule.

Exemples

definir mathnote (entier a) {
    envoyer "J'ai eu" [a] "en math";
}

definir mathnote (entier a) {
    variable entier b -> a;
    envoyer "Program a eu" [b] " en math et toi " [a] "! Bon...";
}

definir msg (texte message) {
    varaible m -> "Yo la compagnie !";
    envoyer m;
    changer m -> message;
    envoyer m;
}

Appeler une fonction

Pour appeler une fonction on va utiliser l'instruction appeler, cette dernière a besoin d'un seul argument si vous n'avez pas donné d'arguments dans la fonction.

Sans argument.

Voici le format : appeler [nom de la fonction];

Cela est simple et rapide. Voici des exemples :

definir msg () {
    envoyer "Yo je suis une fonction";
}
appeler msg;

Avec un ou des arguments.

Si vous avez des arguments dans la fonction, vous devez obligatoirement leur donner une valeur avec l'instruction appeler.

Voici le format : appeler [nom de la fonction] : [nom de l'argument] [valeur];

Si vous avez plusieurs arguments dans la fonction, vous séparez par une virgule, comme ceci :

appeler [nom de la fonction] : [nom de l'argument] [valeur], [nom de l'argument] [valeur];

Attention, il faut toujours que le type de la valeur que vous donnez soit de même type que l'argument.

Exemples

definir m(texte msg) {
    envoyer msg;
}
appeler m : msg "Yo c'est moi Program";

definir m(texte msg, entier a) {
    envoyer msg;
    envoyer "J'ai" [a] "ans";
}
appeler m : msg "Yo c'est moi Program.", a 25;

definir m(decimal note, entier notetwo) {
    envoyer "J'ai" [note] "de moyenne... Mais j'ai eu" [notetwo] "en math";
}
appeler m : note 12.2, a 16;

L'instruction "renvoyer"

Cette instruction permet d'avoir une valeur en retour lorsqu'on appelle une fonction.

On l'insère dans une fonction avant la fermeture de cette dernière.

Voici le format à suivre : renvoyer [valeur];

Ensuite voici un petit exemple :

definir name() { 
    envoyer "Une fonction pour recuperer mon nom.";
    renvoyer "Program";
}

Maintenant, voyons comment récupérer cette dernière.

On va utiliser la déclaration des variables, et on va prendre presque le même format que pour les entrées claviers : variable [type] fonction [nom] -> [arguments];

Alors, vous commencez à avoir l'habitude maintenant mais arguments va reprendre la même chose qu'une appellation classique. Cela dépend si vous avez des arguments ou pas du tout, je vous invite à relire cette partie là si nécessaire.

Voici des exemples :

definir name() { 
    envoyer "Une fonction pour recuperer mon nom.";
    renvoyer "Program";
}

variable texte fonction nom -> name;

definir note() { 
    renvoyer 15;
}

variable auto fonction manote -> note;

definir ms(texte msg) { 
    renvoyer "bye";
}

variable auto fonction m -> ms : msg "Yo";
envoyer m;

definir ms(texte msg, texte fin) { 
    envoyer msg;
    renvoyer "bye";
}

variable auto fonction m -> ms : msg "Yo c'est moi, et puis...", fin "Enfaite...";
envoyer m;