Généralités

R est un langage peu typé : pas de cast explicite. Mais il y a la notion de classe.

Affectation (assignation) :

• myVar = c(4, 5)
• myVar <- c(4, 5) : l'écriture R courante.
• assign("myVar", c(4, 5) : une autre écriture.

Les assignations sont locales à une fonction, sauf si elles sont faites avec l'opérateur de super-assignation auquel cas elles sont globales (persistent à la sortie de la fonction) :

• myVar <<- c(4, 5) : survit à la sortie de la fonction.
• assign("myVar", c(4, 5), envir = globalenv()) : autre formulation.

Mais attention, la variable est une variable globale différente de celle de la variable locale même si les deux ont le même nom !

f <- function() {
  a <- 2
  a <<- 1
  print(paste("local = ", a, sep = ""))
}

a <- 0
f()
print(paste("global = ", a, sep = ""))

donne :

[1] "local = 2"
[1] "global = 1"

NULL :

• v <- NULL : affecte la valeur nulle (pas de valeur) à la variable v.
• is.null(v) : renvoie TRUE si la variable v est NULL, FALSE sinon.
• Attention : on ne peut pas faire v == NULL !

Impression d'un objet :

• print(myVar) : imprime la variable.
• print("toto"): imprime toto. Attention, n'interprête pas les \t et \n. Ce n'est pas la bonne façon d'imprimer.
• cat("myVar = ", myVar, "\n", sep = "") : imprime chaque élément, avec comme séparateur rien du tout (par défaut, c'est un espace).

Description sommaire d'un objet : str(myVar) : permet de voir un résumé de la variable, par exemple toutes les colonnes d'un dataframe avec leur type.

Integer sous R : v <- 232L

typeof : donne le type interne de stockage :

• typeof(c("a", "b")) : donne character.
• typeof(c(TRUE, FALSE)) : donne logical.
• typeof(3 + 4i) : donne complex.
• typeof(factor(c("a", "b"))) : donne integer (car facteurs stockés sous forme d'entier en interne).
• typeof(matrix(c(2.3, 4.2, 3, 7), nrow = 2)) : donne double.
• typeof(data.frame(a = c(3, 4), b = c(5, 6))) : donne list.
• typeof(lm) : donne closure (fonction).

classe : attribut d'un objet qui précise à quelle classe il appartient et permet de savoir quelle méthode invoquer quand on donne le nom d'une fonction. Un objet peut appartenir en même temps à plusieurs classes !

• class(c("a", "b")) : donne character.
• class(c(TRUE, FALSE)) : donne logical.
• class(3 + 4i) : donne complex.
• class(factor(c("a", "b"))) : donne factor.
• class(matrix(c(2.3, 4.2, 3, 7), nrow = 2)) : donne matrix.
• class(data.frame(a = c(3, 4), b = c(5, 6))) : donne data.frame.

Mécanisme des classes : quand une fonction générique "func" est appliquée à un objet de classes c("firstClass", "secondClass"), le système cherche l'existence de la fonction func.firstClass, ou sinon func.secondClass, ou sinon, la fonction par défaut func.default. Si l'objet n'a pas de classe, c'est directement func.default qui est utilisée.

unclass(obj) : renvoie une copie de obj ou l'attribut class a été retiré.

Un objet peut avoir des attributs :

• fr <- data.frame(a = c(3, 4), b = c(5, 6), row.names = c("A", "B")); attributes(fr) : renvoie une liste des attributs de fr :

  $names
  [1] "a" "b"
  
  $row.names
  [1] "A" "B"
  
  $class
  [1] "data.frame"
    

• On peut accéder à un attribut de fr par attributes(fr)[[1]] ou attributes(fr)$names (comme pour toute liste).
• Autre façon d'accéder à un attribut de fr : attr(fr, "names").
• On peut rajouter un attribut à un objet quel qu'il soit (même un simple vecteur) par : attr(myObj, "myName") <- myValue

On peut indiquer au début d'un script des options :

• options() : donne la liste des options disponibles.
• options(digits = 20) : affiche 20 chiffres après la virgule.
• getOption("digits") : indique à combien l'option digits est fixée.
• warn permet de régler la façon dont les warnings sont affichés :
  • options(warn = -1) : ignore tous les warnings.
  • options(warn = 0) : warnings sont stockés et affichés en fin d'exécution si pas plus de 10, sinon, affichage seulement du nombre de warnings. C'est le défaut. (les warnings sont sortis sur stderr).
  • options(warn = 1) : affiche tous les warnings.
  • options(warn = 2) : transforme les warnings en erreur fatale.
• options(echo = FALSE) : évite l'affichage à l'écran des commandes R quand celui-ci est exécuté de manière traditionnelle (R --vanilla <myScript.R).
• options(expressions = 1000) : augmente le nombre d'expressions imbriquées évaluables (défaut à 500).

appel d'une fonction de manière indirecte :

• do.call(myFunc, myArgs) : appelle la fonction myFunc avec les arguments myArgs
• m <- matrix(c(1, 2, 3, 4), nrow = 2); do.call(apply, list(m, 1, sum)) : appelle la fonction apply avec comme arguments la matrice, la valeur 1 et la fonction sum
• m <- matrix(c(1, 2, 3, 4), nrow = 2); do.call(apply, list(m, 1, sum)) : appelle la fonction apply avec comme arguments la matrice, la valeur 1 et la fonction sum
• m <- matrix(c(1, 2, 3, 4), nrow = 2); myFunc = "apply"; do.call(myFunc, list(m, 1, "sum")) : marche aussi.