0Pricing
R Academy · Lektion

Kommentare, Stil und Lesbarkeit

Schreiben Sie sauberen, dokumentierten R-Code nach dem tidyverse Style Guide.

Kommentare, Stil und Lesbarkeit ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Einzeilige Kommentare mit #

In R leitet das Zeichen # einen Kommentar ein. Alles von # bis zum Zeilenende wird vom Interpreter ignoriert. Kommentare sind für Menschen gedacht – erklären Sie warum, nicht nur was.

# This is a comment — R ignores it completely
x <- 42   # inline comment after code

# Bad comment (states the obvious):
y <- y + 1   # add 1 to y

# Good comment (explains intent):
y <- y + 1   # shift index to 1-based for output display

cat('x =', x)

Abschnittsüberschriften mit ------

Eine weit verbreitete Konvention in R besteht darin, Abschnittsüberschriften zu erstellen, indem Sie nach dem Kommentartext mindestens vier Bindestriche, Gleichheitszeichen oder Rauten hinzufügen. RStudio erkennt diese und nimmt sie zur einfachen Navigation in die Dokumentübersicht auf.

# Data Loading -------------------------------------------------------

# This section loads raw CSV files from the data/ folder

# Data Cleaning =======================================================

# Remove duplicates and fix missing values

# Modeling ############################################################

# Fit linear model and evaluate

cat('Section headers improve navigation')

Namenskonvention snake_case

Der Styleguide für tidyverse empfiehlt snake_case für alle Objektnamen: kleingeschriebene Wörter, die durch Unterstriche getrennt sind. Vermeiden Sie Punkte (die in anderen Sprachen wie Methodenaufrufe aussehen) und camelCase, um eine einheitliche Schreibweise zu gewährleisten.

# Good: snake_case
user_age <- 25
monthly_revenue <- 15000
calculate_mean <- function(x) mean(x)

# Avoid: dots in names (looks like OOP method calls)
user.age <- 25       # confusing

# Avoid: camelCase (inconsistent with tidyverse)
userAge <- 25

# Avoid: ALL_CAPS (reserved for true constants by convention)
MAX_RETRIES <- 3     # acceptable for config constants only

cat('snake_case wins')

Leerzeichen um Operatoren

Setzen Sie immer Leerzeichen um Zuweisungs- und Vergleichsoperatoren. Dies verbessert die Lesbarkeit erheblich. Die einzige Ausnahme sind Funktionsargumentlisten, in denen = Argumentnamen zuweist.

# Good: spaces around <- and operators
x <- 10
y <- x + 5
result <- x * y - 2
is_valid <- x > 0 & y < 100

# Bad: cramped
x<-10
y<-x+5

# Function arguments: = without extra spaces is fine
mean(x = c(1, 2, 3), na.rm = TRUE)

# Comparison operators also need spaces
if (x > 0) cat('positive')
if (x >= 0 & y <= 100) cat('in range')

Für Zuweisungen <- statt = verwenden

Obwohl R auf der obersten Ebene = für Zuweisungen erlaubt, besteht die klare Konvention in der Community darin, <- für die Zuweisung von Objekten zu verwenden und = ausschließlich für Argumentwerte von Funktionen zu reservieren. Diese Unterscheidung macht Code auf einen Blick deutlich lesbarer.

# Correct: <- for assignment
name <- 'Alice'
score <- 95.5
results <- c(1, 2, 3)

# Correct: = inside function calls
round(3.14159, digits = 2)
read.csv('data.csv', header = TRUE, sep = ',')

# Avoid: = for top-level assignment
# name = 'Alice'   <- works but not idiomatic

cat('Assignment convention:', name, score)

Die Zeilenbegrenzung auf 80 Zeichen

Wenn Sie Zeilen auf weniger als 80 Zeichen beschränken, bleibt der Code in Editoren mit geteilten Ansichten, auf gedruckten Seiten und in Code-Review-Werkzeugen lesbar. In RStudio können Sie über Tools → Global Options → Code → Display eine Randmarkierung bei Spalte 80 anzeigen.

# Bad: one very long line (hard to read)
result <- some_function(argument_one = 'value', argument_two = 100, argument_three = TRUE, argument_four = 'long_string')

# Good: break at commas, indent continuation
result <- some_function(
  argument_one   = 'value',
  argument_two   = 100,
  argument_three = TRUE,
  argument_four  = 'long_string'
)

cat('Readable at 80 chars')

Keine Semikolons

Anders als JavaScript oder C benötigt R am Ende von Anweisungen keine Semikolons. Semikolons können verwendet werden, um mehrere Anweisungen in eine Zeile zu schreiben, doch der Styleguide empfiehlt: eine Anweisung pro Zeile, keine Semikolons.

# Bad: semicolons and multiple statements per line
x <- 1; y <- 2; z <- x + y

# Good: one statement per line
x <- 1
y <- 2
z <- x + y

# The semicolon form is only acceptable in very short
# interactive throwaway code, never in scripts
cat('z =', z)

Lesbare Variablennamen

Wählen Sie Namen, die beschreibend, aber nicht übermäßig lang sind. Eine gute Faustregel: Wenn Sie sechs Monate später länger als eine Sekunde überlegen müssen, um einen Variablennamen zu verstehen, ist er zu kurz oder zu kryptisch.

# Too cryptic:
d <- read.csv('data.csv')
tmp <- d[d$v1 > 0, ]
r <- lm(v2 ~ v1, data = tmp)

# Good names:
sales_data    <- read.csv('data.csv')
positive_rows <- sales_data[sales_data$revenue > 0, ]
revenue_model <- lm(profit ~ revenue, data = positive_rows)

# Avoid abbreviations that are not universally understood:
# n_obs is fine (number of observations)
# nrv is not (nobody knows what this is)

cat('Names tell the story')

Geschweifte Klammern und Einrückung

Der Styleguide für tidyverse legt Folgendes fest: Die öffnende Klammer { steht in derselben Zeile, die schließende Klammer } in einer eigenen Zeile. Verwenden Sie zur Einrückung 2 Leerzeichen (keine Tabulatoren). Eine einheitliche Einrückung ist entscheidend, um verschachtelte Logik zu lesen.

# Good style: brace on same line, 2-space indent
if (x > 0) {
  cat('positive\n')
} else {
  cat('non-positive\n')
}

# Good function definition:
calculate_bmi <- function(weight_kg, height_m) {
  bmi <- weight_kg / height_m^2
  round(bmi, 1)
}

cat('BMI:', calculate_bmi(70, 1.75))

Leerzeichen in Klammern und bei Kommas

Setzen Sie nach jedem Komma ein Leerzeichen (wie in der deutschen Schreibweise), aber kein Leerzeichen vor einem Komma oder direkt innerhalb von Klammern. Dies entspricht der mathematischen Schreibweise und macht Indizierungen leichter lesbar.

# Good: space after comma, not before
x <- c(1, 2, 3, 4, 5)
m <- matrix(1:9, nrow = 3, ncol = 3)

# Subsetting: no space before [ or inside []
first_row <- m[1, ]      # good
value     <- m[2, 3]    # good

# Bad:
# c(1,2,3)     <- no space after comma
# m[ 1, ]      <- space after [
# m[1 , ]      <- space before comma

cat('Spacing is consistent')

styler und lintr verwenden

Zwei Werkzeuge automatisieren die Einhaltung von Formatierungsregeln in R. styler formatiert Ihren Code entsprechend dem Styleguide für tidyverse neu. lintr prüft Ihren Code statisch auf Stilprobleme und mögliche Fehler, ohne ihn auszuführen. Beide Werkzeuge lassen sich in RStudio integrieren.

# styler: reformat a file automatically
# install.packages('styler')
# styler::style_file('my_script.R')

# styler: reformat the whole project
# styler::style_dir('R/')

# lintr: check for style and potential bugs
# install.packages('lintr')
# lintr::lint('my_script.R')

# lintr reports issues like:
#   line 10: [object_name_linter] Variable 'myVar' should use snake_case
#   line 15: [spaces_around_ops_linter] No space before '<-'

cat('Style tools: styler + lintr')

Kurzer Test

Welche der folgenden Schreibweisen für eine Zuweisung in R entspricht dem Styleguide für tidyverse?

Stil und Lesbarkeit – Die wichtigsten Punkte

Gut formatierter R-Code ist professionell, wartbar und eignet sich für die Zusammenarbeit:

  • # für Kommentare – erklären Sie warum, nicht nur was
  • Abschnittsüberschriften mit ------ oder ====== zur Navigation
  • snake_case für alle Objekt- und Funktionsnamen
  • Leerzeichen um <-, +, == usw.
  • <- für Zuweisungen verwenden, = nur in Funktionsargumenten
  • Maximal 80 Zeichen pro Zeile – lange Aufrufe auf mehrere Zeilen verteilen
  • Keine Semikolons – eine Anweisung pro Zeile
  • Einrückung mit 2 Leerzeichen, öffnende { in derselben Zeile
  • styler zum automatischen Formatieren und lintr zum Erkennen von Problemen verwenden
# Putting it all together:

# Calculate summary statistics ----------------------------------------
calculate_summary <- function(values, remove_na = TRUE) {
  cleaned <- values[!is.na(values)]
  list(
    mean   = mean(cleaned),
    median = median(cleaned),
    sd     = sd(cleaned)
  )
}

test_scores <- c(85, 90, NA, 78, 92, 88)
stats <- calculate_summary(test_scores)
cat('Mean:', stats$mean, '\n')
cat('SD:  ', stats$sd)

Häufig gestellte Fragen

Ist die Lektion „Kommentare, Stil und Lesbarkeit“ kostenlos?

Ja — der vollständige Text von „Kommentare, Stil und Lesbarkeit“ 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 „Kommentare, Stil und Lesbarkeit“?

Schreiben Sie sauberen, dokumentierten R-Code nach dem tidyverse Style Guide. 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 2 von 4.

Wie lange dauert die Lektion „Kommentare, Stil und Lesbarkeit“?

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

  1. Skripte mit source() laden
  2. Kommentare, Stil und Lesbarkeit
  3. Arbeitsverzeichnisse und Dateipfade
  4. R-Projekte und Workspace-Verwaltung
← Zurück zu R Academy