Variables et affectation en R : <-, = et assign()

Comment créer une variable en R

Une variable en R, c'est un nom attaché à une valeur. Tu en crées une avec la flèche d'affectation <- : le nom avant la flèche, la valeur après.

age <- 30
name <- "Rosa"
is_admin <- TRUE

cat(age, name, is_admin, "\n")

Trois variables, trois types de valeur différents, et aucune déclaration de type nulle part - R déduit le type de la valeur elle-même (plus de détails dans les types de données). Une fois qu'une variable existe, tu l'utilises partout où tu utiliserais la valeur :

price <- 19.99
quantity <- 3
total <- price * quantity

cat("You owe", total, "\n")

La réaffectation fonctionne pareil. Une variable passe volontiers à une nouvelle valeur - même à un nouveau type - dès que tu réaffectes :

mood <- "hopeful"
cat(mood, "\n")

mood <- 42
cat(mood, "\n")

R n'a pas protesté qu'une chaîne devienne un nombre. Cette souplesse est pratique, mais si le sens d'une variable change en cours de script, c'est généralement le signe qu'il faut choisir un nouveau nom à la place.

Pourquoi R utilise <- plutôt que =

Voici la question que tout le monde pose : age = 30 fonctionne aussi, alors pourquoi tous les livres, guides de style et packages R utilisent-ils la flèche ?

Parce que = en R est deux choses différentes selon l'endroit où il apparaît. Au niveau supérieur, il affecte. Dans un appel de fonction, il associe un argument par son nom - et ne crée pas de variable :

values <- c(1, 5, NA, 9)

# Here = means "the argument called na.rm is TRUE".
# It does not create a variable named na.rm.
result <- mean(values, na.rm = TRUE)
cat(result, "\n")

Si tu essayais mean(values, na.rm <- TRUE), tu créerais accidentellement une variable globale appelée na.rm et tu passerais TRUE par position - légal, faux, et difficile à repérer. La convention qui garde tout ça lisible est simple :

• <- signifie toujours affectation.
• = signifie toujours « cet argument reçoit cette valeur » dans un appel de fonction.

Respecte cette séparation et chaque ligne de R que tu lis te dit d'un coup d'œil si quelque chose est créé ou passé. C'est la règle de style la plus universelle du monde R - RStudio donne même à <- son propre raccourci clavier (Alt+-).

Les cousins rarement utilisés : ->, = et assign()

R a deux autres façons d'affecter, toutes deux bonnes à reconnaître même si tu les écris rarement.

La flèche inversée -> affecte dans l'autre sens - valeur d'abord, nom ensuite :

2 + 2 -> answer
cat(answer, "\n")

Tu la verras parfois à la fin d'un long pipeline (« calcule tout ça, puis stocke-le »), mais la plupart des guides de style conseillent de l'éviter : les lecteurs balaient le début de la ligne pour trouver le nom défini.

assign() crée une variable à partir d'une chaîne, ce qui veut dire que le nom peut être construit à l'exécution :

assign("score", 100)
cat(score, "\n")

for (i in 1:3) {
    assign(paste0("run_", i), i * 10)
}
cat(run_1, run_2, run_3, "\n")

Ça a l'air malin et c'est presque toujours le mauvais outil - un ensemble de variables numérotées est en réalité un vecteur ou une liste déguisée. Ne sors assign() que quand un nom doit vraiment être calculé ; son pendant get("score") lit une variable par son nom sous forme de chaîne.

Règles de nommage

R accepte les noms qui :

• Contiennent des lettres, des chiffres, des points (.) et des underscores (_).
• Commencent par une lettre, ou par un point non suivi d'un chiffre.
• Ne sont pas des mots réservés (if, for, TRUE, NULL, function, et quelques autres).

Donc ceux-ci sont tous valides :

user_name <- "Ada"
score2 <- 99
my.total <- 150

cat(user_name, score2, my.total, "\n")

Et ceux-ci ne le sont pas :

• 2nd_user - ne peut pas commencer par un chiffre.
• _temp - ne peut pas commencer par un underscore non plus (contrairement à Python).
• user-name - un tiret est une soustraction, pas un caractère de nom.
• TRUE - mot réservé.

Les noms sont sensibles à la casse : total, Total et TOTAL sont trois variables sans rapport, et R ne t'avertira pas quand une faute de frappe en crée une nouvelle.

total <- 10
Total <- 20
cat(total, Total, "\n")

Lister et supprimer : ls() et rm()

Chaque variable que tu crées atterrit dans l'espace de travail (l'environnement global). ls() liste ce qui s'y trouve, et rm() supprime :

a <- 1
b <- 2
print(ls())

rm(a)
print(ls())

Deux détails à connaître. D'abord, rm(list = ls()) efface tout l'espace de travail - pratique en début de session exploratoire, destructeur partout ailleurs. Ensuite, les noms qui commencent par un point (comme .cache) sont cachés de ls() sauf si tu appelles ls(all.names = TRUE) - la même convention que les fichiers cachés sous Unix.

Conventions de nommage : utilise le snake_case

Au-delà des règles strictes, la communauté R moderne (et le guide de style tidyverse) a convergé vers des conventions :

• lower_snake_case pour les variables et les fonctions : retry_count, fit_model.
• Les points dans les noms sont légaux mais datés : R de base est plein de noms de l'époque data.frame comme my.data, mais le point porte aussi un sens dans le système S3 de R (print.data.frame, c'est « la méthode print pour les data frames »), donc le code récent les évite.
• Pas de préfixes hongrois, pas de camelCase - tu verras du camelCase dans les vieux packages, mais l'écosystème s'est fixé sur le snake_case.
• R n'a pas de vraies constantes ; la convention est de nommer les pseudo-constantes en majuscules (MAX_RETRIES <- 5) et de simplement ne pas les réaffecter.

Choisis des noms descriptifs et reste cohérent. avg_score coûte quatre frappes de plus que as et épargne à chaque futur lecteur un aller-retour en haut du script.

Ce que tu retiens

• name <- value crée une variable ; la communauté réserve = aux arguments de fonction.
• -> et assign() existent ; tu les liras plus souvent que tu ne devrais les écrire.
• Les noms utilisent lettres, chiffres, points et underscores ; ils ne peuvent pas commencer par un chiffre ou un underscore, et ils sont sensibles à la casse.
• ls() montre l'espace de travail, rm() le nettoie.
• Écris en snake_case et ton code ressemblera au R que tout le monde écrit aujourd'hui.

Prochaine étape : quels genres de valeurs ces variables contiennent réellement - numeric, integer, character et logical.