Dans les chapitres précédents, nous avons développé plusieurs exemples de code. Par exemple, nous avons calculé la valeur présente d'une série de paiements. Dans cette section, nous verrons qu'il est possible de faire ces mêmes calculs en se servant de nos propres fonctions. Creer des fonctions nous permet d'éviter de réécrire le code qui fait le même calcule à chaque fois.
Syntaxe:
{R}
NonDeFonction <- function(arg1, arg2, ...) {
codeAexécuter
return(resultatSouhaité)
}
prenons l'exemple classique où l'on crée une fonction qui additionne deux éléments;
somme<-function(x,y){
return(x+y)
}
Appliquons cette fonction maintenant:
somme(2,3)
Gestion de erreurs,
On peut éviter des erreurs d'exécution par le moyen de conditions. Toutesfois, cette solution nécessite une connaissance des erreurs qui peuvent survenir. Dans notre exemple d'adition de deux éléments, on peut demander au programme de vérifier si les éléments à additionner sont d'abord de type numérique;
somme<-function(x,y){
if(is.numeric(x) & is.numeric(y)){
return(x+y)
}else {
print("veuillez vérifier vos arguments")
}
}
somme(2,2)
Toutefois, lorsqu'on essaie ceci:
somme(2, "a")
Dans l'exemple précédent, nous avons eu comme résultat la somme de deux éléments, il est possible de faire en sorte que le résultat de la fonction nous retourne plusieurs éléments. Par exemple, dans la fonction operation
suivante, elle nous retourne trois opérations sur les deux arguments de la fonction; la somme, la différence,la multiplication , ainsi que la division des deux éléments;
operation<-function(x,y){
if(is.numeric(x) & is.numeric(y)){
return(c(x+y, x-y, x*y, x/y))
}else {
print("veuillez vérifier vos arguments")
}
}
operation(2,3)
operation_l<-function(x,y){
if(is.numeric(x) & is.numeric(y)){
list(x+y, x-y, x*y, x/y)
}else {
print("veuillez vérifier vos arguments")
}
}
resultat_sousForme_liste<-operation_l(2,3)
resultat_sousForme_liste
Ainsi, on peut extraire un seul (ou plusieurs) élément de notre liste résultante;
resultat_sousForme_liste[2]
Au lieu d'insérer deux éléments comme argument de notre fonction operation_l
, insérons deux vecteurs et regardons la différence entre le résultat de la fonction operation_l
et la fonction operation
xvec<-c(1:5)
yvec<-c(6:10)
operation_l(xvec, yvec)
Maintenant, appliquons la fonction operation
sur les mêmes vecteurs et inspectons à nouveau le résultat:
operation(xvec, yvec)
Si l'on voulait par exemple extraire le deuxième élément de la liste, qui est le résultat de la soustraction dans notre exemple, il est plus difficile de le faire avec la fonction operation
.
operation_l(xvec, yvec)[2]
au lieu de:
operation(xvec, yvec)[6:10]
Où il est nécessaire de connaitre les index du seul vecteur résultant.
operation_l
formals(operation_l)
operation_l<-function(x=1,y=1){
if(is.numeric(x) & is.numeric(y)){
list(x+y, x-y, x*y, x/y)
}else {
print("veuillez vérifier vos arguments")
}
}
Lorsqu'on écrit la fonction sans aucun argument;
operation_l()
On obtient le résultat de nos valeurs par défaut
Best practice
Il est très conseillé de bien documenter les fonctions que vous créez. Cela vous aide lorsque vous revisez ou corrigez votre code. Sans oublier que la bonne documentation aide la personne qui relie votre code à bien comprendre ce que vous voulez avoir comme résultat. Que ce soit dans un contexte académique (travaux, examen....etc.) Et surtout dans le contexte professionnel, où les codes sont plus longs et plus lourds à lire lorsque la documentation est quasi absente.
operation_l<-function(x=1,y=1){
# Cette fonction calcule l'adition, soustraction, multiplication
# ainsi que la division de deux vecteurs
# Args:
# x: La valeur du premier vecteur, la valeur par défaut étant =1
# y: La valeur du deuxième vecteur, la valeur par défaut étant =1
#
# retourne:
# une liste du résultat des opérations ....
if(is.numeric(x) & is.numeric(y)){
list(x+y, x-y, x*y, x/y)
}
# Gestion d'erreurs
else {
print("veuillez vérifier vos arguments")
}
}