0Pricing
R Academy · Leçon

Utiliser source() pour charger des scripts

Exécutez des scripts R externes et partagez du code entre les fichiers avec source().

Utiliser source() pour charger des scripts est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Pourquoi utiliser source() ?

À mesure que vos projets R prennent de l’ampleur, conserver tout le code dans un seul fichier devient ingérable. La fonction source() vous permet de charger et d’exécuter un fichier de script R externe, en répartissant votre travail dans des modules logiques et réutilisables.

C’est la base d’un développement R organisé.

# Imagine helpers.R contains:
# add <- function(a, b) a + b
# multiply <- function(a, b) a * b

# Load it into your main script:
source('helpers.R')

# Now use the functions defined there:
result <- add(3, 5)
cat('Result:', result)

Syntaxe de base de source()

La forme la plus simple de source() accepte un chemin de fichier comme seul argument. Le fichier est lu et chaque expression qu’il contient est évaluée dans l’environnement courant, comme si vous aviez saisi le code directement.

# source() with a relative path (file in working directory)
source('my_functions.R')

# source() with an absolute path
source('/Users/alice/projects/utils.R')

# After sourcing, all objects and functions defined
# in the file are available in your current session
cat('Script loaded successfully')

Paramètre echo

Le paramètre echo détermine si chaque expression du fichier chargé est affichée dans la console lors de son exécution. Par défaut, echo = FALSE, ce qui laisse votre console propre. La valeur TRUE est utile pour le débogage.

# Default: silent loading (echo = FALSE)
source('helpers.R')

# Verbose: print each expression as it runs
source('helpers.R', echo = TRUE)

# echo = TRUE output looks like:
# > add <- function(a, b) a + b
# > multiply <- function(a, b) a * b
cat('Done')

print.eval et verbose

Deux autres paramètres vous offrent un contrôle plus précis de la sortie. print.eval détermine si les résultats des expressions sont affichés, de façon similaire au mode interactif. verbose affiche des informations supplémentaires sur le processus de chargement lui-même.

# print.eval: print the VALUE of each expression
source('helpers.R', echo = TRUE, print.eval = TRUE)

# verbose: extra details like file name and line numbers
source('helpers.R', verbose = TRUE)

# Typical use: debugging a complex script
# source('complex_analysis.R', echo = TRUE, print.eval = TRUE)
cat('Parameters explored')

Paramètre local — portée isolée

Par défaut, source() exécute le code dans l’environnement global, de sorte que tous les objets créés apparaissent dans votre espace de travail. Définir local = TRUE exécute le script dans un nouvel environnement isolé et préserve la propreté de votre espace de travail global.

# Without local: objects pollute global env
source('data_prep.R')        # x, y, temp_df all appear in ls()

# With local = TRUE: objects stay inside
source('data_prep.R', local = TRUE)
# x, y, temp_df are NOT in your global workspace

# Verify nothing leaked:
cat('Objects in workspace:', length(ls()))

# local can also be an environment object:
my_env <- new.env()
source('data_prep.R', local = my_env)

sys.source() pour un chargement plus sûr

sys.source() est une alternative de plus bas niveau qui évite une partie de la surcharge de source(). Elle ne modifie pas le répertoire de travail et n’évalue pas les options keepSource. Elle est souvent utilisée lors du développement de packages et dans les outils internes.

# sys.source() loads a file into a specific environment
utils_env <- new.env()
sys.source('utils.R', envir = utils_env)

# Access functions from that environment explicitly
result <- utils_env$my_helper(10)
cat('Result:', result)

# sys.source does not echo or verbose options
# It is faster and more predictable for package internals
cat('sys.source demo complete')

Chemins relatifs ou absolus

L’utilisation de chemins relatifs dans source() rend votre projet portable : le chemin du fichier est résolu par rapport au répertoire de travail courant. Les chemins absolus fonctionnent partout, mais cessent de fonctionner lorsque vous déplacez le projet. Privilégiez les chemins relatifs dans les flux de travail fondés sur des projets.

# Relative path — resolved from getwd()
source('R/helpers.R')          # good for projects
source('scripts/utils.R')      # subfolder
source('../shared/common.R')   # parent folder

# Absolute path — fragile, machine-specific
source('/Users/alice/project/R/helpers.R')

# Check current working directory first:
cat('Working dir:', getwd())

# Best practice: use file.path() for clarity
source(file.path('R', 'helpers.R'))

Charger plusieurs fichiers

Vous pouvez appeler source() plusieurs fois pour charger plusieurs fichiers auxiliaires. Une structure courante consiste à disposer d’un unique point d’entrée, tel que setup.R ou _targets.R, qui charge tous les modules nécessaires dans le bon ordre.

# main.R — entry point that loads all modules
source('R/data_loading.R')
source('R/cleaning.R')
source('R/analysis.R')
source('R/plotting.R')

# Or source all .R files in a directory:
r_files <- list.files('R', pattern = '\\.R$', full.names = TRUE)
for (f in r_files) {
  source(f)
  cat('Loaded:', f, '\n')
}
cat('All modules loaded')

source() avec chdir

Le paramètre chdir modifie temporairement le répertoire de travail pour utiliser, pendant l’exécution, le répertoire qui contient le fichier chargé. Cela est utile lorsqu’un script auxiliaire utilise en interne ses propres chemins relatifs.

# Suppose scripts/analysis.R uses source('helpers.R')
# and helpers.R is also in scripts/

# Without chdir: R looks for helpers.R in YOUR working dir
source('scripts/analysis.R')          # may fail

# With chdir = TRUE: working dir shifts to scripts/ temporarily
source('scripts/analysis.R', chdir = TRUE)   # helpers.R found!

# After source() returns, working dir goes back to original
cat('Working dir restored:', getwd())

Charger au démarrage avec .Rprofile

Le fichier .Rprofile de votre répertoire personnel (ou de la racine du projet) est exécuté automatiquement à chaque démarrage de R. Vous pouvez y utiliser source() pour charger automatiquement des utilitaires, définir des options ou attacher des packages au début de chaque session.

# .Rprofile (in ~ or project root):
# source('~/.R/my_utils.R')     # load personal helpers
# options(scipen = 999)          # no scientific notation

# To open and edit .Rprofile:
file.edit('~/.Rprofile')

# To see where .Rprofile files are looked for:
cat(Sys.getenv('R_PROFILE_USER'))

# Caution: heavy .Rprofile slows R startup
# Keep it minimal — load only what you always need
cat('.Rprofile concept shown')

source() en pratique — structure de projet

Une structure claire, utilisée dans les projets réels, consiste à organiser votre projet avec un dossier R/ contenant tous les scripts auxiliaires et un unique fichier run.R ou main.R qui les charge. Le projet est ainsi facile à reproduire et à partager.

# Project structure:
# my_project/
#   run.R             <- entry point
#   R/
#     01_load.R       <- data loading
#     02_clean.R      <- data cleaning
#     03_model.R      <- modeling
#     04_report.R     <- output

# run.R content:
cat('=== Starting analysis ===\n')
source('R/01_load.R')
source('R/02_clean.R')
source('R/03_model.R')
source('R/04_report.R')
cat('=== Analysis complete ===\n')

Vérification rapide

Quel paramètre de source() empêche les objets créés dans le fichier chargé d’apparaître dans l’environnement global ?

source() — points essentiels

source() est la fonctionnalité intégrée de R pour modulariser le code :

  • source('file.R') — charge et exécute un script dans l’environnement global
  • echo = TRUE — affiche chaque expression, ce qui est idéal pour le débogage
  • local = TRUE — exécute le code de manière isolée, sans effet secondaire global
  • chdir = TRUE — déplace temporairement le répertoire de travail vers l’emplacement du fichier
  • sys.source() — alternative de bas niveau utilisée dans les packages
  • Privilégiez les chemins relatifs et les flux de travail fondés sur des projets pour assurer la portabilité
  • Utilisez .Rprofile pour charger automatiquement les scripts auxiliaires au démarrage de R
# Quick reference
source('R/helpers.R')                        # basic load
source('R/helpers.R', echo = TRUE)           # verbose
source('R/helpers.R', local = TRUE)          # isolated
source('scripts/run.R', chdir = TRUE)        # local paths

env <- new.env()
sys.source('R/helpers.R', envir = env)       # low-level

cat('source() mastered!')

Questions Fréquemment Posées

La leçon « Utiliser source() pour charger des scripts » est-elle gratuite ?

Oui — le texte complet de « Utiliser source() pour charger des scripts » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Utiliser source() pour charger des scripts » ?

Exécutez des scripts R externes et partagez du code entre les fichiers avec source(). Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer R Academy ?

Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Utiliser source() pour charger des scripts » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon R Academy ?

Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Utiliser source() pour charger des scripts
  2. Commentaires, style et lisibilité
  3. Répertoires de travail et chemins de fichiers
  4. Projets R et gestion de l’espace de travail
← Retour à R Academy