# Les fonctions ## 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; ``` --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://program-4.gitbook.io/french-programming-language/instructions/les-fonctions.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.