Comme dans la plupart des langages de programmation, le coeur de la programmation R consiste en l'écriture de fonctions. Une fonction est un groupe d'instructions qui prend des entrées, les utilise pour calculer d'autres valeurs et renvoie un résultat.
En guise d'introduction, définissons une fonction nommée oddcount (), dont le but est de compter les nombres impairs dans un vecteur d'entiers. Normalement, nous composons le code de fonction à l'aide d'un éditeur de texte et l'enregistrons dans un fichier, mais dans cet exemple rapide, nous l'introduirons ligne par ligne dans le mode interactif de R. Nous appellerons ensuite la fonction sur quelques cas de test.
# compte le nombre d'entiers impairs dans x
> oddcount <- function (x) {
+ k <- 0 # assigner 0 à k + pour (n en x) {
+ if (n %% 2 == 1) k <- k + 1 # %% est l'opérateur modulo
+}
+ retour (k)
+}
> oddcount (c (1,3,5))
[1] 3
> oddcount (c (1,2,3,7,9))
[1] 4
Premièrement, nous avons dit à R que nous voulions définir une fonction nommée oddcount avec un argument, x. L'attelle gauche délimite le début du corps de la fonction. Nous avons écrit une déclaration R par ligne.
Jusqu'à ce que le corps de la fonction soit terminé, R vous rappelle que vous êtes toujours dans la définition en utilisant + comme invite, au lieu de l'habituel>. (En fait, + est un caractère de continuation de ligne, pas une invite pour une nouvelle entrée.) R reprend l'invite> après avoir finalement entré une accolade droite pour terminer le corps de la fonction.
Après avoir défini la fonction, nous avons évalué deux appels à oddcount (). Comme il y a trois nombres impairs dans le vecteur (1,3,5), l'appel oddcount (c (1,3,5)) renvoie la valeur 3. Il y a quatre nombres impairs dans (1,2,3,7, 9), de sorte que l'appel sec¬ond retourne 4.
Notez que l'opérateur modulo pour l'arithmétique du reste est %% dans R, comme indiqué par le commentaire. Par exemple, 38 divisé par 7 laisse un reste de 3:
> 38 %% 7 [1] 3
Par exemple, voyons ce qui se passe avec le code suivant:
pour (n en x) {
if (n %% 2 == 1) k <- k + 1
}
Tout d'abord, il met n à x [1], puis il teste cette valeur pour être impair ou pair. Si la valeur est impaire, ce qui est le cas ici, la variable de comptage k est incrémentée. Alors n est mis à x [2], testé pour être impair ou pair, et ainsi de suite.
D'ailleurs, les programmeurs C / C ++ pourraient être tentés d'écrire la boucle précédente comme ceci:
pour (i en 1: longueur (x)) {
if (x [i] %% 2 == 1) k <- k + 1
}
Ici, length (x) est le nombre d'éléments dans x. Supposons qu'il y ait 25 éléments. Alors 1: longueur (x) signifie 1:25, ce qui signifie à son tour 1,2,3, ..., 25. Ce code fonctionnerait également (sauf si x devait avoir une longueur de 0), mais l'un des principaux thèmes de la programmation R est d'éviter les boucles si possible; sinon, gardez les boucles simples. Regardez encore notre formulation originale:
pour (n en x) {
if (n %% 2 == 1) k <- k + 1
}
C'est plus simple et plus propre, car nous n'avons pas besoin d'utiliser la fonction length () et l'indexation des tableaux.
À la fin du code, nous utilisons l'instruction return:
retour (k)
Cela a la fonction retourner la valeur calculée de k au code qui l'a appelé. Cependant, simplement écrire ce qui suit fonctionne aussi:
k
Les fonctions R retourneront la dernière valeur calculée s'il n'y a pas d'appel de retour explicite (). Cependant, cette approche doit être utilisée avec précaution, comme nous le verrons à la section 7.4.1.
Dans la terminologie du langage de programmation, x est l'argument formel (ou paramètre formel) de la fonction oddcount (). Dans le premier appel de fonction de l'exemple précédent, c (1,3,5) est appelé argument réel. Ces termes font allusion au fait que x dans la définition de la fonction est juste un espace réservé, alors que c (1,3,5) est la valeur réellement utilisée dans le calcul. De même, dans l'appel de la seconde fonction, c (1,2,3,7,9) est l'argument réel.
1.3.1 Portée variable
Une variable visible uniquement dans un corps de fonction est dite locale à cette fonction. Dans oddcount (), k et n sont des variables locales. Ils disparaissent après le retour de la fonction:
> oddcount (c (1,2,3,7,9))
[1] 4
> n
Erreur: l'objet 'n' n'a pas été trouvé
Il est très important de noter que les paramètres formels dans une fonction R sont des variables locales. Supposons que nous fassions l'appel de fonction suivant:
> z <- c (2,6,7)
> oddcount (z)

Supposons maintenant que le code de oddcount () change x. Alors z ne changerait pas. Après l'appel de oddcount (), z aurait la même valeur qu'avant. Pour évaluer un appel de fonction, R copie chaque argument réel dans la variable de paramètre locale correspondante et les modifications apportées à cette variable ne sont pas visibles en dehors de la fonction. Les règles de portée telles que celles-ci seront discutées en détail au chapitre 7.
Les variables créées en dehors des fonctions sont globales et sont également disponibles dans les fonctions. Voici un exemple:
> f <- fonction (x) retour (x + y)
> y <- 3
> f (5)
[1] 8
Ici y est une variable globale.
Une variable globale peut être écrite à partir d'une fonction en utilisant R
opérateur de super-affectation, << -. Ceci est également discuté au chapitre 7.
1.3.2 Arguments par défaut
R utilise aussi fréquemment les arguments par défaut. Considérons une définition de fonction comme ceci:
> g <- fonction (x, y = 2, z = T) {...}
Ici y sera initialisé à 2 si le programmeur ne spécifie pas y dans l'appel. De même, z aura la valeur par défaut TRUE.
Maintenant considérez cet appel:
> g (l2, z = FAUX)
Ici, la valeur 12 est l'argument réel de x, et nous acceptons la valeur par défaut de 2 pour y, mais nous remplaçons la valeur par défaut de z, en définissant sa valeur sur FALSE.
L'exemple précédent montre également que, comme de nombreux langages de programmation, R a un type booléen; c'est-à-dire qu'il a les valeurs logiques TRUE et FALSE.
NOTE R permet d'abréger TRUE et FALSE en T et F. Cependant, vous pouvez choisir de ne pas abréger ces valeurs pour éviter des problèmes si vous avez une variable nommée T ou F.