Syntaxe de base

Les commentaires commencent par '#' (mettre '##' sous le mode emacs ESS pour avoir un affichage "electric" correct avec "tab").

Les différents "lignes" de code peuvent être séparées par des retours chariots et/ou des ';' (';' non nécessaire en fin de ligne, sauf si plusieurs ordres par ligne).

On peut grouper des expressions avec {} et le résultat est la dernière expression : {expr1; expr2; ... ; exprk}

if : comme en C :

• if (expr1) expr2 else if (expr3) expr4 else expr5
• if (expr1) {expr2; expr3;} : accolades obligatoires si plusieurs expressions (comme en C).

Boucles :

• for (name in vect) expr2 : boucles.
• for (name in vect) {expr2; expr2} : accolades obligatoires si plusieurs expressions (comme en C).
• for (i in 1:length(x)) print(x[i]) : boucle simple avec une séquence.
• while (expr1) expr2 (pareil avec les accolades).
• repeat expr2 : répète l'évaluation d'une expression sans condition, la seule possibilité de sortie étant un break (pareil avec les accolades).
• break : sort de la boucle la plus interne.
• next : reprend immédiatement en début de boucle sans effectuer le reste du corps de boucle (comme continue en C).

switch : évalue le premier argument. Si c'est un nombre, retourne l'élément de numéro correspondant de la liste. Si c'est une chaîne, retourne l'élément nommé correspondant. Le dernier argument est la valeur par défaut :

• switch(paste("a", "a", sep = ""), aa = 2, bb = 3, cc = 4) : retourne 2.
• switch(paste("a", "a", sep = ""), aa = 2, bb = 3, cc = 4) : retourne aussi 2.
• switch("x", aa = 2, bb = 3, cc = 4) : retourne NULL.
• switch("x", aa = 2, bb = 3, cc = 4, 5) : retourne 5.

ifelse : teste la première valeur. Si elle est vraie, renvoie la 2ème, sinon renvoie la 3ème (équivalent de "? : " en C) :

• attention, else évalue systématiquement les 2 valeurs quelque soit la condition ! (essayer par exemple : x <- -3:3; ifelse(x > 0, sqrt(x), sqrt(-x)))
• a <- 3; ifelse(a == 3, "a", "b") : renvoie "a".
• Peut être aussi utilisé sur un vecteur : vect <- seq(5); ifelse(vect == 5:1, "a", "b") : renvoie "b" "b" "a" "b" "b".
• Peut même être utilisée avec des vecteurs comme valeurs de retour : vect <- seq(5); ifelse(vect == 5:1, c("a", "b"), c("A", "B")) : renvoie "A" "B" "a" "B" "A" (principe du recylage de valeurs est alors utilisé si pas assez de valeurs).

Fonctions :

• Définition d'une fonction : func <- function(x, y) {expr1; expr2; return(expr3);}. le return est optionnel (la valeur renvoyée est la dernière expression évaluée).
• avec return, si l'appel de la fonction n'est pas affecté, le résultat est imprimé :

  f <- function(x) {return(x ^ 2)}
  f(4)
  

  imprime 16, ce qui n'aurait pas été le cas si on avait fait : y <- f(4)
  Pour éviter l'impression utiliser invisible :

  f <- function(x) {invisible(x ^ 2)}
  f(4)
  

  n'imprime pas 16, mais se comporte comme return si on avait fait : y <- f(4)
• Utiliser return() sans argument si on ne veut rien retourner.
• On peut donner des valeurs par défaut à une fonction : func <- function(x, y = 2) {x * y}
• Passage des paramètres à une fonction :
  • Par position : func(4, 3)
  • Par nom : func(y = 3, x = 4)
  • Un mélange des deux : func(4, y = 3)
  • Les valeurs ayant un défaut ne sont pas obligatoires : func(4)
• Les variables sont passées aux fonctions par valeur, pas par référence ! Donc une fonction ne peut modifier en retour ses paramètres (les paramètres sont recopiés à la première modification).
• Les fonctions sont des objets comme les autres qui peuvent être passés comme paramètres à d'autres fonctions.
• On peut voir le contenu d'une fonction simple simplement en l'évaluant ou en l'imprimant : func ou print(func)

Argument spécial "..." d'une fonction : elle peut avoir cet argument spécial dans sa définition qui pourra être repassé tel quel dans l'appel d'une autre fonction :

> func <- function(x, ...) {print(x); print(paste(..., sep = ","));}
> func("a", "b", "c")
[1] "a"
[1] "b,c"

(c'est vraiment la chaîne "..." qu'il faut indiquer !).

missing : permet de tester si un argument est manquant lors de l'appel d'une fonction :

f <- function(a, b) {
  if (missing(a))
    print("a is missing")
  if (missing(b))
    print("b is missing")
}

f(b = 3)
  

donne

a is missing
  

Evaluation d'une fonction : si func <- function(x, y) {return((x + 1) * y)} :

• do.call : évalue une fonction avec les arguments donnés sous forme de liste : a <- 3; b <- 5; do.call(func, list(a, b)) : donne 20.
• Evaluation avec le nom de la fonction : a <- 3; b <- 5; do.call("func", list(a, b)) : donne aussi 20.
• Evaluation avec des arguments nommés : a <- 3; b <- 5; do.call(func, list(y = a, x = b)) : donne 18.
• Construction de l'appel sans évaluation : a <- 3; b <- 5; call("func", a, b) : renvoie func(3, 5) (évalue les arguments, mais pas la fonction).
• Construction de l'appel sans évaluation avec arguments nommés : a <- 3; b <- 5; call("func", y = a, x = b) : renvoie func(y = 3, x = 5) (évalue les arguments, mais pas la fonction).
• Evaluation : a <- 3; b <- 5; cal <- call("func", a, b); eval(cal) : renvoie 20.

Une fonction peut contenir ses propres définitions de fonctions qui restent alors internes à la fonction (inaccessibles à l'extérieur). Mais, elle peut retourner une fonction ! Exemple :
func <- function(a) {return(function(x) {return(x + a)})}
Alors, do.call(func(4), list(5)) : renvoie 9 !

Manière standard pour une fonction de renvoyer plusieurs valeurs (par exemple, un dataframe, une matrice et un vecteur : renvoyer une liste de ces éléments.

stop("error message") : interrompt l'exécution du programme et imprime le message.

stopifnot(exp1, exp2, ...) : interrompt l'exécution du programme si l'une des expressions n'est pas TRUE et indique alors la première expression pour laquelle la condition n'est pas vérifiée.

quit("no") (ou q("no")) : permet de terminer le programme sans afficher de message d'erreur (et sans sauvegarder le contexte, d'où le "no"). On peut par exemple faire :

if (length(commandArgs(TRUE)) != 1) {
    writeLines("Usage : myScript.R <inputFile>\n", stderr())
    quit("no")
}