1.1 Composantes d’une fonction R

Les composantes d’une fonction R sont :

• la liste de ses arguments, possiblement avec des valeurs par défaut (nous allons y revenir);

args(stats_desc)

## function (x, sortie_matrice) 
## NULL

# ou
formals(stats_desc)

## $x
## 
## 
## $sortie_matrice

• le corps de la fonction, soit les instructions qui la constituent.

body(stats_desc)

## {
##     if (is.numeric(x)) {
##         stats <- c(min = min(x), moy = mean(x), max = max(x))
##     }
##     else if (is.character(x) || is.factor(x)) {
##         stats <- table(x, dnn = NULL)
##     }
##     else {
##         stats <- NA
##     }
##     if (sortie_matrice) {
##         stats <- as.matrix(stats)
##         colnames(stats) <- if (is.character(x) || is.factor(x)) 
##             "frequence"
##         else "stat"
##     }
##     return(stats)
## }

• l’environnement englobant de la fonction (défini plus loin).

environment(stats_desc)

## <environment: R_GlobalEnv>

1.2 Fonction anonyme

Notons qu’une fonction n’a même pas besoin de porter de nom. La grande majorité du temps, une fonction est conçue pour être appelée à plusieurs reprises et il est alors nécessaire qu’elle ait un nom. Cependant, certaines fonctions sont parfois à usage unique.

Par exemple, il est parfois utile de se créer une fonction pour personnaliser le calcul effectué par une fonction de la famille des apply. Si cette fonction est très courte et a peu de chance d’être réutilisée, il n’est pas nécessaire de la nommer.

Voici un exemple. Si nous voulions calculer le minimum, la moyenne et le maximum (comme le fait notre fonction stats_desc) de toutes les variables numériques du jeu de données iris, mais selon le niveau de la variable Species, nous pourrions utiliser trois appels à la fonction aggregate comme suit.

aggregate(formula = . ~ Species, data = iris, FUN = min)

##      Species Sepal.Length Sepal.Width Petal.Length Petal.Width
## 1     setosa          4.3         2.3          1.0         0.1
## 2 versicolor          4.9         2.0          3.0         1.0
## 3  virginica          4.9         2.2          4.5         1.4

aggregate(formula = . ~ Species, data = iris, FUN = mean)

##      Species Sepal.Length Sepal.Width Petal.Length Petal.Width
## 1     setosa        5.006       3.428        1.462       0.246
## 2 versicolor        5.936       2.770        4.260       1.326
## 3  virginica        6.588       2.974        5.552       2.026

aggregate(formula = . ~ Species, data = iris, FUN = max)

##      Species Sepal.Length Sepal.Width Petal.Length Petal.Width
## 1     setosa          5.8         4.4          1.9         0.6
## 2 versicolor          7.0         3.4          5.1         1.8
## 3  virginica          7.9         3.8          6.9         2.5

Nous pourrions aussi créer une fonction qui calcule les trois statistiques et donner cette fonction en entrée à aggregate comme valeur à l’argument FUN.

aggregate(
  formula = . ~ Species,
  data = iris, 
  FUN = function(x) c(min = min(x), moy = mean(x), max = max(x))
)

##      Species Sepal.Length.min Sepal.Length.moy Sepal.Length.max Sepal.Width.min
## 1     setosa            4.300            5.006            5.800           2.300
## 2 versicolor            4.900            5.936            7.000           2.000
## 3  virginica            4.900            6.588            7.900           2.200
##   Sepal.Width.moy Sepal.Width.max Petal.Length.min Petal.Length.moy Petal.Length.max
## 1           3.428           4.400            1.000            1.462            1.900
## 2           2.770           3.400            3.000            4.260            5.100
## 3           2.974           3.800            4.500            5.552            6.900
##   Petal.Width.min Petal.Width.moy Petal.Width.max
## 1           0.100           0.246           0.600
## 2           1.000           1.326           1.800
## 3           1.400           2.026           2.500

Nous n’avons jamais donné de nom à la fonction et cela n’a causé aucun problème. Nous n’avons même pas utilisé d’accolades pour encadrer le corps de la fonction. Ce n’est pas nécessaire lorsque celui-ci est composé d’une seule instruction.

2.1 Valeurs par défaut des arguments

Afin de définir une valeur par défaut pour un argument, il faut accompagner son nom dans l’énumération des arguments d’un opérateur = et d’une expression R retournant la valeur par défaut. Par exemple, dans la fonction stats_desc, il serait préférable de définir un format par défaut pour la sortie.

stats_desc <- function(x, sortie_matrice = FALSE) {
  # Calcul
  if (is.numeric(x)) {
    stats <- c(min = min(x), moy = mean(x), max = max(x))
  } else if (is.character(x) || is.factor(x)) {
    stats <- table(x, dnn = NULL)
  } else {
    stats <- NA
  }
  # Production de la sortie
  if (sortie_matrice) {
    stats <- as.matrix(stats)
    colnames(stats) <- if (is.character(x) || is.factor(x)) "frequence" else "stat"
  }
  return(stats)
}

La liste des arguments de la fonction devient la suivante.

formals(stats_desc)

## $x
## 
## 
## $sortie_matrice
## [1] FALSE

Les arguments qui ne possèdent pas de valeur par défaut sont obligatoires. Si une fonction est appelée sans donner de valeur en entrée à un argument obligatoire, une erreur est produite.

stats_desc(sortie_matrice = FALSE)

## Error in stats_desc(sortie_matrice = FALSE): argument "x" is missing, with no default

Les arguments ayant une valeur par défaut peuvent, pour leur part, ne pas être fournis en entrée, auquel cas leur valeur par défaut est utilisée.

stats_desc(x = iris$Sepal.Length)

##      min      moy      max 
## 4.300000 5.843333 7.900000

args(sample)

## function (x, size, replace = FALSE, prob = NULL) 
## NULL

sample(1:5)

## [1] 4 5 2 1 3

body(sample)

## {
##     if (length(x) == 1L && is.numeric(x) && is.finite(x) && x >= 
##         1) {
##         if (missing(size)) 
##             size <- x
##         sample.int(x, size, replace, prob)
##     }
##     else {
##         if (missing(size)) 
##             size <- length(x)
##         x[sample.int(length(x), size, replace, prob)]
##     }
## }

args(sample.int)

## function (n, size = n, replace = FALSE, prob = NULL, useHash = (!replace && 
##     is.null(prob) && size <= n/2 && n > 1e+07)) 
## NULL

args(cut.default)

## function (x, breaks, labels = NULL, include.lowest = FALSE, right = TRUE, 
##     dig.lab = 3L, ordered_result = FALSE, ...) 
## NULL

if (is.null(labels)) {
  <instructions>  # comportant une nouvelle assignation de valeur à labels
}

table(iris$Species, useNA = "test")

## Error in match.arg(useNA): 'arg' should be one of "no", "ifany", "always"

args(table)

## function (..., exclude = if (useNA == "no") c(NA, NaN), useNA = c("no", 
##     "ifany", "always"), dnn = list.names(...), deparse.level = 1) 
## NULL

useNA <- match.arg(useNA)

stats_desc <- function(x, format_sortie = c("vecteur", "matrice", "liste")) {
  # Calcul
  if (is.numeric(x)) {
    stats <- c(min = min(x), moy = mean(x), max = max(x))
  } else if (is.character(x) || is.factor(x)) {
    stats <- table(x, dnn = NULL)
  } else {
    stats <- NA
  }
  # Production de la sortie
  format_sortie <- match.arg(format_sortie)
  if (format_sortie == "matrice") {
    stats <- as.matrix(stats)
    colnames(stats) <- if (is.character(x) || is.factor(x)) "frequence" else "stat"
  } else if (format_sortie == "liste") {
    stats <- as.list(stats)
  }
  return(stats)
}

stats_desc(x = iris$Sepal.Length)

##      min      moy      max 
## 4.300000 5.843333 7.900000

stats_desc(x = iris$Sepal.Length, format_sortie = "vecteur")

##      min      moy      max 
## 4.300000 5.843333 7.900000

2.2 Appel d’une fonction

Les appels à nos propres fonctions respectent les mêmes règles que les appels à n’importe quelle fonction R. En plus du fonctionnement des valeurs par défaut décrit ci-dessus, rappelons que des valeurs peuvent être fournies aux arguments d’une fonction R par nom complet, par nom partiel ou par position. L’assignation de valeurs aux arguments se fait en respectant les règles de préséances suivantes :

1. d’abord les arguments fournis avec un nom exact se voient assigner une valeur (assignation explicite),
2. puis les arguments fournis avec un nom partiel (encore assignation explicite),
3. et finalement les arguments non nommés, selon leurs positions (assignation implicite).

Voici quelques exemples.

test_appel <- function(x, option, param, parametre) {
  cat("l'argument x prend la valeur", x, "\n")
  cat("l'argument option prend la valeur", option, "\n")
  cat("l'argument param prend la valeur", param, "\n")
  cat("l'argument parametre prend la valeur", parametre, "\n")
}

test_appel(1, 2, 3, 4)

## l'argument x prend la valeur 1 
## l'argument option prend la valeur 2 
## l'argument param prend la valeur 3 
## l'argument parametre prend la valeur 4

test_appel(1, 2, param = 3, opt = 4)

## l'argument x prend la valeur 1 
## l'argument option prend la valeur 4 
## l'argument param prend la valeur 3 
## l'argument parametre prend la valeur 2

Le nom partiel opt a été reconnu comme représentant l’argument option. Un nom partiel pouvant représenter plus d’un argument génère cependant une erreur. C’est le cas du nom partiel par dans l’exemple suivant, qui pourrait référer à l’argument param ou encore à l’argument parametre.

test_appel(1, par = 2, option = 3, 4)

## Error in test_appel(1, par = 2, option = 3, 4): argument 2 matches multiple formal arguments

Une bonne pratique de programmation en R est d’utiliser l’assignation de valeurs aux arguments par positionnement seulement pour les premiers arguments, ceux les plus souvent utilisés. Les arguments moins communs devraient être nommés, en utilisant leurs noms complets, afin de conserver un code facile à comprendre.

2.3 Argument ...

Les deux utilités de l’argument ... ont été mentionnées lors du premier cours. Nous pouvons recourir à cet argument dans nos propres fonctions, en exploitant l’une ou l’autre de ses utilités.

stats_desc_multi <- function(...) {
  args <- list(...)
  lapply(X = args, FUN = stats_desc)
}

stats_desc_multi(iris$Sepal.Length, iris$Petal.Width, iris$Species)

## [[1]]
##      min      moy      max 
## 4.300000 5.843333 7.900000 
## 
## [[2]]
##      min      moy      max 
## 0.100000 1.199333 2.500000 
## 
## [[3]]
##     setosa versicolor  virginica 
##         50         50         50

stats_desc_multi(
  Sepal.Length = iris$Sepal.Length,
  Petal.Width = iris$Petal.Width,
  Species = iris$Species
)

## $Sepal.Length
##      min      moy      max 
## 4.300000 5.843333 7.900000 
## 
## $Petal.Width
##      min      moy      max 
## 0.100000 1.199333 2.500000 
## 
## $Species
##     setosa versicolor  virginica 
##         50         50         50

test_trois_points <- function(...) {
  cat("le premier argument prend la valeur", ..1, "\n")
  cat("le deuxième argument prend la valeur", ..2, "\n")
}

test_trois_points("a", 1, TRUE)

## le premier argument prend la valeur a 
## le deuxième argument prend la valeur 1

test_trois_points("a")

## Error in cat("le deuxième argument prend la valeur", ..2, "\n") : 
##  the ... list contains fewer than 2 elements

test_trois_points <- function(...) {
  if (...length() >= 1) {
    cat("le premier argument prend la valeur", ..1, "\n")
  }
  if (...length() >= 2) {
    cat("le deuxième argument prend la valeur", ..2, "\n")
  }
}

test_trois_points("a")

## le premier argument prend la valeur a

test_trois_points <- function(...) {
  for (i in seq_len(...length())) {
    cat("l'argument", i, "prend la valeur", ...elt(i), "\n")
  }
}

test_trois_points("a", 1, TRUE)

## l'argument 1 prend la valeur a 
## l'argument 2 prend la valeur 1 
## l'argument 3 prend la valeur TRUE

stats_desc <- function(x, format_sortie = c("vecteur", "matrice", "liste"), ...) {
  # Calcul
  if (is.numeric(x)) {
    stats <- c(min = min(x, ...), moy = mean(x, ...), max = max(x, ...))  # ... ici
  } else if (is.character(x) || is.factor(x)) {
    stats <- table(x, dnn = NULL)
  } else {
    stats <- NA
  }
  # Production de la sortie
  format_sortie <- match.arg(format_sortie)
  if (format_sortie == "matrice") {
    stats <- as.matrix(stats)
    colnames(stats) <- if (is.character(x) || is.factor(x)) "frequence" else "stat"
  } else if (format_sortie == "liste") {
    stats <- as.list(stats)
  }
  return(stats)
}

stats_desc(x = c(iris$Sepal.Length, NA))

## min moy max 
##  NA  NA  NA

stats_desc(x = c(iris$Sepal.Length, NA), na.rm = TRUE)

##      min      moy      max 
## 4.300000 5.843333 7.900000

ave(x = Orange$circumference, Orange$Tree, FUN = mean, trim = 0.2)

##  [1]  99.57143  99.57143  99.57143  99.57143  99.57143  99.57143  99.57143 135.28571
##  [9] 135.28571 135.28571 135.28571 135.28571 135.28571 135.28571  94.00000  94.00000
## [17]  94.00000  94.00000  94.00000  94.00000  94.00000 139.28571 139.28571 139.28571
## [25] 139.28571 139.28571 139.28571 139.28571 111.14286 111.14286 111.14286 111.14286
## [33] 111.14286 111.14286 111.14286

ave(x = Orange$circumference, Orange$Tree, FUN = function(x) mean(x, trim = 0.2))

##  [1] 104.4 104.4 104.4 104.4 104.4 104.4 104.4 142.2 142.2 142.2 142.2 142.2 142.2 142.2
## [15]  97.6  97.6  97.6  97.6  97.6  97.6  97.6 145.8 145.8 145.8 145.8 145.8 145.8 145.8
## [29] 114.2 114.2 114.2 114.2 114.2 114.2 114.2

3.1 Sortie d’une fonction

Nous pourrions définir la sortie d’une fonction par ce qui est attrapé si l’appel à la fonction est accompagné d’une assignation à un nom. L’objet ainsi créé est la sortie de la fonction. Les expressions « valeur retournée » et « sortie produite » par un appel à une fonction sont synonymes. Dans la fiche d’aide d’une fonction R, la sortie produite est documentée dans la section intitulée « Value ».

Une fonction R retourne en sortie :

• ce que retourne l’expression donnée en argument à la fonction return dans le corps de la fonction (retour explicite);
• ou, en l’absence d’appel à la fonction return, ce que retourne la dernière expression évaluée dans le corps de la fonction (retour implicite).

Si cette dernière expression ne retourne rien, alors la fonction ne produit aucune sortie. Dans les exemples précédents, la fonction HelloWorld et les fonctions dont le nom débute par test ne contiennent aucun appel à la fonction return et possèdent un appel à la fonction cat comme dernière expression évaluée. La fonction cat imprime (en d’autres mots affiche) un résultat, ce qui constitue un type d’effet de bord, mais ne retourne rien.

sortie_cat <- cat("ceci est un test\n")

## ceci est un test

sortie_cat

## NULL

Nous constatons que l’objet sortie_cat prend la valeur NULL. Ne rien retourner en sortie signifie en réalité, pour une fonction R, retourner l’objet spécial NULL.

Les fonctions test_appel et test_trois_points ne produisent aucune sortie puisqu’elles retournent implicitement ce qu’un appel à la fonction cat retourne, c’est à dire rien. Elles provoquent cependant une impression comme effet de bord.

sortie_test <- test_trois_points("oui")

## l'argument 1 prend la valeur oui

sortie_test

## NULL

La fonction stats_desc utilise la fonction return à la dernière ligne du corps de la fonction pour retourner explicitement l’objet stats. Cependant, le corps de la fonction stats_desc_multi ne contient aucun appel à la fonction return. Celle-ci retourne donc le résultat de lapply(X = args, FUN = stats_desc), car il s’agit de la dernière expression évaluée dans le corps de la fonction. Modifions cette dernière fonction pour expérimenter l’utilisation de la fonction return.

stats_desc_multi <- function(...) {
  args <- list(...)
  return(args)
  cat("Est-ce que cette instruction est évaluée ?")
  lapply(X = args, FUN = stats_desc)
}

stats_desc_multi(rating = attitude$rating, complaints = attitude$complaints)

## $rating
##  [1] 43 63 71 61 81 43 58 71 72 67 64 67 69 68 77 81 74 65 65 50 50 64 53 40 63
## [26] 66 78 48 85 82
## 
## $complaints
##  [1] 51 64 70 63 78 55 67 75 82 61 53 60 62 83 77 90 85 60 70 58 40 61 66 37 54
## [26] 77 75 57 85 82

Cette version de la fonction stats_desc_multi retourne la liste des arguments fournis en entrée plutôt que le résultat de l’appel à lapply à cause de la présence de l’instruction return(args). Les instructions suivant l’appel à la fonction return n’ont même pas été évaluées puisque l’impression demandée par l’appel à la fonction cat ajouté au corps de la fonction n’a pas été produite.

3.2 Retour de plusieurs éléments dans une liste

La sortie d’une fonction est toujours composée d’un seul objet. Pour retourner plusieurs objets, il faut les combiner en un seul objet (typiquement dans une liste), comme dans l’exemple suivant.

stats_desc_multi <- function(...) {
  call <- match.call()
  args <- list(...)
  stats <- lapply(X = args, FUN = stats_desc)
  return(list(stats = stats, call = call))
}

stats_desc_multi(rating = attitude$rating, complaints = attitude$complaints)

## $stats
## $stats$rating
##      min      moy      max 
## 40.00000 64.63333 85.00000 
## 
## $stats$complaints
##  min  moy  max 
## 37.0 66.6 90.0 
## 
## 
## $call
## stats_desc_multi(rating = attitude$rating, complaints = attitude$complaints)

Pour faciliter la réutilisation des résultats, il est souhaitable de toujours nommer les éléments d’une liste retournée en sortie.

3.3 Fonction match.call

L’exemple précédent fait intervenir la fonction match.call. Il est commun pour des fonctions d’ajustement de modèle telles que lm de retourner dans la sortie une copie de l’appel de la fonction.

exemple <- lm(rating ~ raises, data = attitude)
exemple$call

## lm(formula = rating ~ raises, data = attitude)

C’est la fonction match.call qui permet de créer cet élément de la sortie.

Les fonctions match.call et return sont des exemples de fonctions seulement utiles dans le corps d’une fonction. Les appeler directement dans la console retourne une erreur ou une sortie sans intérêt.

3.4 Effets de bord d’une fonction

Comme pour les fonctions Hello World, test_appel et test_trois_points, l’évaluation de l’appel à une fonction peut produire des « effets de bord » (en anglais side effects). Ces effets de bords peuvent être en réalité le but principal de la fonction.

En plus de la production d’une impression avec une fonction telle que print ou cat, un exemple courant d’effet de bord est la production d’un graphique.

sortie_plot <- plot(rating ~ raises, data = attitude)

Certaines fonctions graphiques ne retournent pas d’objet.

sortie_plot

## NULL

Nous savons déjà cependant que d’autres fonctions graphiques retournent un objet en plus de produire un graphique. Il est donc possible pour une fonction R de produire à la fois un effet de bord et une sortie.

sortie_boxplot <- boxplot(x = attitude$rating, xlab = "rating")

sortie_boxplot

## $stats
##      [,1]
## [1,] 40.0
## [2,] 58.0
## [3,] 65.5
## [4,] 72.0
## [5,] 85.0
## 
## $n
## [1] 30
## 
## $conf
##          [,1]
## [1,] 61.46146
## [2,] 69.53854
## 
## $out
## numeric(0)
## 
## $group
## numeric(0)
## 
## $names
## [1] ""

Un autre exemple d’effet de bord est l’écriture dans un fichier externe. Par exemple, la fonction write.table ne retourne rien dans l’environnement de travail de la session R, mais enregistre des données dans un fichier externe, sur le disque de l’ordinateur.

Finalement, toute interaction avec l’environnement de travail ou la session R peut être considérée comme un effet de bord. Les fonctions suivantes sont toutes des exemples de fonctions ayant des effets de bord :

• library : charge un package, ce qui modifie le chemin de recherche de R;
• setwd : modifie le répertoire de travail;
• options : modifie les options de la session R;
• par : modifie les paramètres graphiques;
• etc.

4.1 Passage d’arguments par valeur

Lors de l’appel de la plupart des fonctions R, lorsqu’un objet est assigné à un argument, une copie de cet objet est créée et l’évaluation des instructions du corps de la fonction affecte cette copie et non l’objet d’origine. Ce mécanisme est appelé en informatique le « passage d’arguments par valeur ».

Un autre mécanisme possible de passage d’arguments est le « passage par référence ». Avec ce type de passage, les objets passés ne sont pas recopiés et les instructions du corps d’une fonction peuvent modifier l’objet d’origine. En R, ce type de passage est très rare. Une exception notable à cette observation est le package data.table, qui utilise le passage par référence pour certaines de ses fonctions (notamment l’opérateur :=, les fonctions setorder et setcolorder), comme nous l’avons mentionné dans les notes sur le prétraitement de données en R.

Illustrons ici le passage d’argument de loin le plus usuel en R : le passage d’arguments par valeur. Supposons que notre environnement de travail comporte un objet nommé x contenant le nombre 5.

x <- 5
x

## [1] 5

Créons une simple fonction R qui ajoute une unité à des nombres.

ajoute_1 <- function(x) x + 1

Maintenant, appelons cette fonction en lui donnant en entrée l’objet x de notre environnement de travail.

ajoute_1(x = x)

## [1] 6

La fonction retourne le résultat de x + 1, soit 6. Mais est-ce que l’objet x a pour autant changé?

x

## [1] 5

Non. Il contient toujours la valeur 5.

Remarquez qu’ici le nom x a été utilisé pour deux entités distinctes :

• un objet dans notre environnement de travail,
• un argument de la fonction ajoute_1.

Dans l’instruction ajoute_1(x = x), nous avons assigné la valeur contenue dans l’objet x à l’argument portant le même nom.

Comment pourrions-nous modifier l’objet x de notre environnement de travail à l’aide de la fonction ajoute_1 ? Il faudrait assigner le résultat de l’instruction ajoute_1(x = x) au nom x comme suit.

x <- ajoute_1(x = x)

En fait, cette commande écrase l’ancien objet x par un nouveau, contenant la valeur retournée par
ajoute_1(x = x).

x

## [1] 6

4.2 Portée lexicale

Trouver la valeur des arguments et des variables locales en cours d’évaluation de l’appel à une fonction est simple pour R. Ces objets se trouvent directement dans l’environnement d’évaluation de la fonction. On dit en informatique qu’ils ont une portée locale.

Mais comment R trouve-t-il la valeur des objets appelés à l’intérieur d’une fonction, qui ne sont ni des arguments ni des variables locales?

Chaque langage de programmation suit une certaine règle pour résoudre ce problème. Les deux règles les plus courantes sont l’utilisation d’une portée lexicale (en anglais lexical scoping) ou encore d’une portée dynamique (en anglais dynamic scoping).

Avec une portée lexicale, si un objet appelé n’est pas trouvé dans l’environnement d’évaluation de l’appel à une fonction, le programme va le chercher dans l’environnement d’où la fonction a été créée, nommé environnement englobant (en anglais enclosing environment). Avec une portée dynamique, le programme va plutôt le chercher dans l’environnement d’où la fonction a été appelée, nommé environnement d’appel (en anglais calling environment).

R utilise la portée lexicale.

Voici un petit exemple pour illustrer la portée lexicale.

a <- 1
b <- 2
f <- function(x) {
  a*x + b
}

Quelle valeur sera retournée par f(x = 5)? Est-ce 1*5 + 2 = 7? Oui!

f(x = 5)

## [1] 7

Les objets nommés a et b ne se retrouvaient pas dans l’environnement d’exécution de la fonction. Alors R a cherché leurs valeurs dans l’environnement englobant de la fonction f, qui est ici l’environnement de travail.

environment(f)

## <environment: R_GlobalEnv>

Il a trouvé a = 1 et b = 2. La fonction environment retourne l’environnement englobant d’une fonction.

Modifions maintenant l’exemple comme suit.

g <- function(x) {
  a <- 3
  b <- 4
  f(x = x)
}

Quelle valeur sera retournée par g(x = 5)? Est-ce 3*5 + 4 = 19? Non!

g(x = 5)

## [1] 7

La fonction g est appelée dans l’environnement de travail. Elle appelle elle-même f. L’environnement d’appel de f est donc l’environnement d’exécution de g. Par contre, l’environnement englobant de f n’a pas changé. Il est encore l’environnement de travail, car c’est dans cet environnement que la fonction a été définie.

environment(f)

## <environment: R_GlobalEnv>

La portée lexicale permet de s’assurer que le fonctionnement de l’évaluation de l’appel à une fonction ne dépende pas du contexte dans lequel la fonction est appelée. Il dépend seulement de l’environnement d’où la fonction a été créée.

Si la portée en R était par défaut dynamique, g(x = 5) aurait retourné la valeur 19.

Et si f était créée à l’intérieur de la fonction g?

g <- function(x) {
  f <- function(x) {
    a*x + b
  }
  a <- 3
  b <- 4
  f(x = x)
}

Que retourne g(x = 5) maintenant?

g(x = 5)

## [1] 19

L’environnement englobant de f est maintenant l’environnement d’exécution de g, car f a été défini dans le corps de la fonction g.

Notons que l’environnement englobant des fonctions disponibles en R autres que celles que nous avons créées en cours de session est l’espace de noms du package d’où provient la fonction. Par exemple, l’environnement englobant de la fonction mean est l’espace de noms du package base. Nous verrons ce qu’est un espace de noms dans les notes sur l’utilisation de packages R.

environment(mean)

## <environment: namespace:base>

4.3 Chemin de recherche complet

Le chemin de recherche des valeurs des objets lors de l’évaluation de l’appel à une fonction en R ne s’arrête pas à l’environnement d’exécution de la fonction suivi de l’environnement englobant de la fonction. Si l’environnement englobant est l’environnement d’exécution d’une autre fonction, alors la recherche se poursuit dans l’environnement englobant de cette fonction. Plusieurs environnements englobants peuvent ainsi être imbriqués. Ensuite, l’environnement de travail est toujours ajouté au chemin de recherche s’il n’est pas directement l’environnement englobant (potentiellement à la base d’une hiérarchie d’environnements englobants). Et de là, le chemin de recherche se poursuit par les environnements de tous les packages chargés, tel que vu dans les notes sur des informations techniques concernant R. Nous pouvons donc utiliser, dans les fonctions que nous créons, des fonctions provenant d’autres packages. Il faut seulement s’assurer que ces packages soient chargés pour que nos fonctions roulent sans erreur.

Figure 4.1: Exemple de chemin de recherche lors de l’évaluation de l’appel à une fonction R

4.4 Bonnes pratiques dans la création d’une fonction

Il est recommandé d’utiliser dans une fonction uniquement des objets que nous sommes certains de pouvoir atteindre. L’idéal est de se limiter aux arguments de la fonction, aux objets créés dans la fonction (variables locales) ainsi qu’aux objets se trouvant dans des packages chargés.

Ceux qui comprennent bien le concept de portée lexical peuvent aussi s’amuser à utiliser des objets dans l’environnement englobant d’une fonction.

Cependant, il est risqué d’utiliser les objets de l’environnement de travail, même si cet environnement se retrouve toujours dans le chemin de recherche de valeurs des objets lors de l’évaluation de l’appel à une fonction. Le contenu de l’environnement de travail est constamment modifié au fil de nos sessions. Aussi, si nous partageons nos fonctions avec une autre personne, nous ne contrôlons pas le contenu de l’environnement de travail pendant la session R de cette personne.

Ces recommandations s’appliquent au code dans le corps d’une fonction, mais aussi aux instructions définissant les valeurs par défaut des arguments. Nous avons appris que ces instructions sont évaluées dans le corps de la fonction. Elles peuvent donc contenir sans problème d’autres arguments de la fonction. Cependant, nous devrions éviter d’utiliser des objets provenant de l’environnement de travail dans ces instructions.

5.1 Étapes de développement conseillées

1. Planifier le travail (pas de programmation encore)
   • définir clairement la tâche à accomplir par la fonction et la sortie qu’elle doit produire;
   • prévoir les étapes à suivre afin d’effectuer cette tâche;
   • identifier les arguments devant être fournis en entrée à la fonction.
2. Développer le corps de la fonction
   • écrire le programme par étapes, d’abord sans former la fonction, en commentant bien le code et en travaillant sur des mini-données test;
   • pour chaque petite étape ou sous-tâche, tester interactivement si le programme produit le résultat escompté (tester souvent en cours de travail, ainsi il y a moins de débogage à faire).
3. Créer la fonction à partir du programme développé.
4. Documenter la fonction : les informations minimales à fournir sont
   • ce que la fonction fait,
   • quels arguments la fonction accepte en entrée (utilités, formats acceptés, valeurs par défaut),
   • ce que la fonction produit comme résultat (sortie retournée et/ou effet de bord).

D’autres étapes de développement seront abordées au prochain cours.

x <- c(6, 3, 5.5, 1, 0, -5)

sum(x %% 2 == 1)

## [1] 3

k <- 0
for (n in x) {
  if (n %% 2 == 1) {
    k <- k + 1
  }
}
k

## [1] 3

compte_impair_vectoriel <- function(x) {
  sum(x %% 2 == 1)
}

compte_impair_boucle <- function(x) {
  k <- 0
  for (n in x) {
    if (n %% 2 == 1) {
      k <- k + 1
    }
  }
  k
}

compte_impair_vectoriel <- function(x) {
  # Fonction qui compte combien de nombres entiers impairs contient un vecteur numérique
  # Argument en entrée : x = vecteur numérique
  # Sortie : le nombre de nombres entiers impairs dans x
  sum(x %% 2 == 1)
}

# Fonction qui compte combien de nombres entiers impairs contient un vecteur numérique
# Argument en entrée : x = vecteur numérique
# Sortie : le nombre de nombres entiers impairs dans x
compte_impair_boucle <- function(x) {
  k <- 0
  for (n in x) {
    if (n %% 2 == 1) {
      k <- k + 1
    }
  }
  k
}

x <- round(runif(1000000, -10, 10))

system.time(compte_impair_vectoriel(x))

##    user  system elapsed 
##    0.01    0.02    0.03

system.time(compte_impair_boucle(x))

##    user  system elapsed 
##    0.20    0.00    0.22