R Academy · Lektion

Skripte mit source() laden

Führen Sie externe R-Skripte aus und teilen Sie Code mithilfe von source() über mehrere Dateien hinweg.

Skripte mit source() laden ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum source() verwenden?

Wenn Ihre R-Projekte wachsen, wird es unübersichtlich, den gesamten Code in einer Datei zu verwalten. Mit der Funktion source() können Sie eine externe R-Skriptdatei laden und ausführen und Ihre Arbeit in logische, wiederverwendbare Module aufteilen.

Dies bildet die Grundlage für eine strukturierte R-Entwicklung.

# 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)

Grundlegende Syntax von source()

Die einfachste Form von source() erwartet einen Dateipfad als einziges Argument. Die Datei wird gelesen und jeder darin enthaltene Ausdruck wird in der aktuellen Umgebung ausgewertet – genau so, als hätten Sie den Code direkt eingegeben.

# 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')

Der Parameter echo

Der Parameter echo steuert, ob jeder Ausdruck aus der eingebundenen Datei bei seiner Ausführung in der Konsole ausgegeben wird. Standardmäßig gilt echo = FALSE, sodass die Konsole übersichtlich bleibt. Die Einstellung TRUE ist beim Debuggen hilfreich.

# 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 und verbose

Zwei weitere Parameter ermöglichen eine genauere Kontrolle über die Ausgabe. print.eval steuert, ob die Ergebnisse von Ausdrücken ausgegeben werden (ähnlich wie im interaktiven Modus). verbose gibt zusätzliche Informationen über den Vorgang des Einlesens und Ausführens aus.

# 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')

Der Parameter local – isolierter Gültigkeitsbereich

Standardmäßig führt source() den Code in der globalen Umgebung aus, sodass alle erstellten Objekte in Ihrem Workspace erscheinen. Mit local = TRUE wird das Skript in einer neuen, isolierten Umgebung ausgeführt, sodass Ihr globaler Workspace übersichtlich bleibt.

# 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)

Sichereres Laden mit sys.source()

sys.source() ist eine Alternative auf niedrigerer Ebene, die einen Teil des Overheads von source() vermeidet. Das Arbeitsverzeichnis wird nicht geändert und Optionen für keepSource werden nicht ausgewertet. Die Funktion wird häufig bei der Paketentwicklung und in internen Werkzeugen verwendet.

# 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')

Relative und absolute Pfade

Die Verwendung von relativen Pfaden in source() macht Ihr Projekt portabel – der Dateipfad wird relativ zum aktuellen Arbeitsverzeichnis aufgelöst. Absolute Pfade funktionieren überall, werden jedoch ungültig, wenn Sie das Projekt verschieben. Bevorzugen Sie in projektbasierten Arbeitsabläufen relative Pfade.

# 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'))

Mehrere Dateien einlesen

Sie können source() mehrmals aufrufen, um mehrere Hilfsdateien zu laden. Ein gängiges Muster ist eine einzelne Einstiegsdatei im Stil von setup.R oder _targets.R, die alle benötigten Module in der richtigen Reihenfolge einliest.

# 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() mit chdir

Der Parameter chdir ändert während der Ausführung vorübergehend das Arbeitsverzeichnis in das Verzeichnis, das die eingelesene Datei enthält. Dies ist hilfreich, wenn ein Hilfsskript intern eigene relative Pfade verwendet.

# 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())

Beim Start einlesen mit .Rprofile

Die Datei .Rprofile in Ihrem Home-Verzeichnis (oder im Projektstammverzeichnis) wird bei jedem Start von R automatisch ausgeführt. Sie können darin source() verwenden, um bei jedem Sitzungsstart automatisch Hilfsfunktionen zu laden, Optionen festzulegen oder Pakete einzubinden.

# .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() in der Praxis – Projektstruktur

Ein sauberes Muster aus der Praxis besteht darin, Ihr Projekt mit einem Ordner R/ für alle Hilfsskripte und einer einzelnen Datei run.R oder main.R zu organisieren, die diese einliest. Dadurch lässt sich das Projekt leicht reproduzieren und weitergeben.

# 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')

Kurzer Test

Welcher Parameter von source() verhindert, dass im eingelesenen Skript erstellte Objekte in der globalen Umgebung erscheinen?

source() – Die wichtigsten Punkte

source() ist die in R integrierte Möglichkeit, Code zu modularisieren:

source('file.R') – ein Skript in der globalen Umgebung laden und ausführen
echo = TRUE – jeden Ausdruck ausgeben (ideal zum Debuggen)
local = TRUE – isoliert ausführen, ohne globale Seiteneffekte
chdir = TRUE – das Arbeitsverzeichnis vorübergehend an den Speicherort der Datei verlagern
sys.source() – eine Alternative auf niedriger Ebene, die in Paketen verwendet wird
Für Portabilität relative Pfade und projektbasierte Arbeitsabläufe bevorzugen
.Rprofile verwenden, um Hilfsfunktionen beim Start von R automatisch einzulesen

# 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!')

Häufig gestellte Fragen

Ist die Lektion „Skripte mit source() laden“ kostenlos?

Ja — der vollständige Text von „Skripte mit source() laden“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Skripte mit source() laden“?

Führen Sie externe R-Skripte aus und teilen Sie Code mithilfe von source() über mehrere Dateien hinweg. Du übst R Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um R Academy zu starten?

Keine Vorkenntnisse erforderlich. R Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Skripte mit source() laden“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser R Academy-Lektion Code schreiben und ausführen?

Ja. Jede R Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu R Academy