0Pricing
R Academy · Lektion

Überblick über R's Typsystem

Verstehen Sie die Typen double, integer, character, logical und complex.

Überblick über R's Typsystem 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.

Das Typsystem von R

R verfügt über ein umfangreiches Typsystem. Jedes Objekt besitzt eine Klasse (eine übergeordnete Kategorie) und einen Typ (den untergeordneten Speichermodus). Wenn Sie beides verstehen, können Sie korrekten und effizienten Code schreiben und typbezogene Fehler beheben.

# Check class and type of various objects
cat('class(42L)    :', class(42L), '
')
cat('typeof(42L)   :', typeof(42L), '
')
cat('class(3.14)   :', class(3.14), '
')
cat('typeof(3.14)  :', typeof(3.14), '
')
cat('class(TRUE)   :', class(TRUE), '
')
cat('class("hello"):', class('hello'), '
')

class() vs. typeof()

class(x) gibt die übergeordnete Kategorie zurück, die R für sein objektorientiertes System verwendet (z. B. 'integer', 'numeric', 'matrix'). typeof(x) gibt den untergeordneten C-Speichertyp zurück (z. B. 'integer', 'double', 'closure').

m <- matrix(1:4, nrow = 2)
cat('class(matrix)  :', class(m), '
')   # matrix array
cat('typeof(matrix) :', typeof(m), '
')  # integer

f <- factor(c('a', 'b', 'a'))
cat('class(factor)  :', class(f), '
')   # factor
cat('typeof(factor) :', typeof(f), '
')  # integer (stored as int!)

cat('class(list)    :', class(list()), '
')  # list
cat('typeof(list)   :', typeof(list()), '
') # list

is.numeric() – Prüfung auf numerische Werte

is.numeric(x) gibt sowohl für integer- als auch für double-Werte (und numerische Matrizen) TRUE zurück. Die Funktion prüft den numerischen Obertyp, nicht den konkreten Speichermodus.

cat('is.numeric(3.14):', is.numeric(3.14), '
')    # TRUE (double)
cat('is.numeric(3L):  ', is.numeric(3L), '
')      # TRUE (integer)
cat('is.numeric(TRUE):', is.numeric(TRUE), '
')    # FALSE
cat('is.numeric("3"): ', is.numeric('3'), '
')     # FALSE
cat('is.numeric(NA):  ', is.numeric(NA), '
')      # FALSE (NA is logical)

is.integer() vs. is.double()

is.integer() prüft speziell auf Integer-Speicher (erzeugt mit dem Suffix L oder mit as.integer()). is.double() prüft auf Gleitkomma-Speicher (Double). Beide sind Teilmengen des numerischen Typs.

x_int <- 5L
x_dbl <- 5.0

cat('--- x_int = 5L ---
')
cat('is.integer:', is.integer(x_int), '
')  # TRUE
cat('is.double: ', is.double(x_int), '
')   # FALSE
cat('is.numeric:', is.numeric(x_int), '
')  # TRUE

cat('--- x_dbl = 5.0 ---
')
cat('is.integer:', is.integer(x_dbl), '
')  # FALSE
cat('is.double: ', is.double(x_dbl), '
')   # TRUE
cat('is.numeric:', is.numeric(x_dbl), '
')  # TRUE

is.character() – Prüfung auf Zeichenketten

is.character(x) gibt TRUE zurück, wenn x ein Zeichenkettenvektor ist. Verwenden Sie die Funktion, um Eingaben zu validieren, die Text enthalten sollen, oder um numerische von zeichenkettenbasierten NA-Typen zu unterscheiden.

greetings <- c('hello', 'world', 'R')
numbers <- c(1, 2, 3)
numeric_string <- '42'

cat('is.character(greetings):      ', is.character(greetings), '
')
cat('is.character(numbers):        ', is.character(numbers), '
')
cat('is.character(numeric_string): ', is.character(numeric_string), '
')
cat('is.character(NA_character_):  ', is.character(NA_character_), '
')

is.logical() – Prüfung auf boolesche Werte

is.logical(x) gibt TRUE zurück, wenn x logische (boolesche) Werte enthält. Beachten Sie, dass das untypisierte NA standardmäßig ein logischer Wert ist.

flags <- c(TRUE, FALSE, TRUE, NA)
cat('is.logical(flags): ', is.logical(flags), '
')   # TRUE
cat('is.logical(NA):    ', is.logical(NA), '
')      # TRUE (default NA is logical)
cat('is.logical(1):     ', is.logical(1), '
')       # FALSE
cat('is.logical("TRUE"):', is.logical('TRUE'), '
')  # FALSE
cat('typeof(NA):        ', typeof(NA), '
')          # logical

Typhierarchie von R

Die atomaren Typen von R bilden eine Hierarchie vom einfachsten zum komplexesten Typ: logical < integer < double < complex < character. Wenn Sie in einem Vektor Typen mischen, wandelt R alle Elemente in den komplexesten vorhandenen Typ um.

# Type hierarchy in action
cat('c(TRUE, 1L) type:     ', typeof(c(TRUE, 1L)), '
')   # integer
cat('c(1L, 1.5) type:      ', typeof(c(1L, 1.5)), '
')   # double
cat('c(1.5, 1+0i) type:    ', typeof(c(1.5, 1+0i)), '
') # complex
cat('c(1+0i, "a") type:   ', typeof(c(1+0i, 'a')), '
')  # character
cat('c(TRUE, "x") type:    ', typeof(c(TRUE, 'x')), '
') # character

Typen programmgesteuert untersuchen

Sie können Funktionen zur Typeninspektion schreiben, um eine Liste von Objekten zu überprüfen. Die Kombination aus class(), typeof() und length() liefert eine umfassende Zusammenfassung der Struktur eines beliebigen Objekts.

describe_type <- function(x, label) {
  cat(label, ': class =', class(x), ', typeof =', typeof(x),
      ', length =', length(x), '
')
}

describe_type(42L,         'integer literal')
describe_type(3.14,        'double literal')
describe_type(TRUE,        'logical')
describe_type('hello',     'character')
describe_type(c(1,2,3),    'numeric vector')
describe_type(list(1,'a'), 'list')

storage.mode() und mode()

storage.mode(x) ähnelt typeof(x), verwendet jedoch die S3-Namenskonvention (gibt beispielsweise 'double' statt 'double' zurück). mode(x) liefert eine etwas gröbere Gruppierung, die Integer und Double unter 'numeric' zusammenfasst.

x_int <- 5L
x_dbl <- 5.0

cat('mode(5L):         ', mode(x_int), '
')          # numeric
cat('mode(5.0):        ', mode(x_dbl), '
')          # numeric
cat('storage.mode(5L): ', storage.mode(x_int), '
')  # integer
cat('storage.mode(5.0):', storage.mode(x_dbl), '
')  # double
# mode() lumps int+dbl; storage.mode() / typeof() distinguish them

Typeninspektion für Listen und Data Frames

Bei komplexeren Objekten wie Listen und Data Frames wendet sapply(df, class) class() auf jede Spalte an und liefert einen benannten Vektor mit den Spaltentypen – eine schnelle Möglichkeit, das Schema eines Data Frames zu überprüfen.

df <- data.frame(
  id      = 1:3,
  name    = c('Alice', 'Bob', 'Carol'),
  score   = c(88.5, 79.0, 92.3),
  passed  = c(TRUE, TRUE, TRUE)
)
cat('Column types:
')
print(sapply(df, class))
cat('Column typeof:
')
print(sapply(df, typeof))

Zusammenfassung des Typsystems

Hier finden Sie eine kurze Übersicht über die Werkzeuge zur Typeninspektion in R:

  • class(x) – übergeordneter S3-Klassenname
  • typeof(x) – untergeordneter C-Speichertyp
  • is.numeric(x) – TRUE für Integer oder Double
  • is.integer(x) – TRUE nur für Integer-Speicher
  • is.double(x) – TRUE nur für Double-Speicher (Gleitkomma)
  • is.character(x) – TRUE für Zeichenketten
  • is.logical(x) – TRUE für TRUE/FALSE/NA
x <- 42L
cat('class(42L):       ', class(x), '
')
cat('typeof(42L):      ', typeof(x), '
')
cat('is.numeric(42L):  ', is.numeric(x), '
')
cat('is.integer(42L):  ', is.integer(x), '
')
cat('is.double(42L):   ', is.double(x), '
')
cat('is.character(42L):', is.character(x), '
')

Schnelltest

Was gibt is.numeric(5L) in R zurück?

Zusammenfassung: Das Typsystem von R

Gute Arbeit! Die wichtigsten Erkenntnisse aus dieser Lektion:

  • class(x) gibt den übergeordneten Typ zurück; typeof(x) gibt den untergeordneten Speichertyp zurück
  • is.numeric() ist sowohl für Integer als auch für Double TRUE
  • is.integer() und is.double() unterscheiden die beiden numerischen Untertypen
  • Typhierarchie von R (niedrig → hoch): logical → integer → double → complex → character
  • Das Mischen von Typen in einem Vektor löst eine automatische Umwandlung in den höchsten Typ aus
  • sapply(df, class) überprüft alle Spaltentypen in einem Data Frame
# Type audit function
audit_types <- function(x, name = 'x') {
  cat(name, ': class=', class(x), ', typeof=', typeof(x),
      ', is.numeric=', is.numeric(x), '
')
}
audit_types(1L,      'integer')
audit_types(1.0,     'double')
audit_types(TRUE,    'logical')
audit_types('hello', 'character')
audit_types(1+2i,    'complex')

Häufig gestellte Fragen

Ist die Lektion „Überblick über R's Typsystem“ kostenlos?

Ja — der vollständige Text von „Überblick über R's Typsystem“ 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 „Überblick über R's Typsystem“?

Verstehen Sie die Typen double, integer, character, logical und complex. 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 „Überblick über R's Typsystem“?

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. Überblick über R's Typsystem
  2. Zwischen numerischen Typen konvertieren
  3. Konvertierung von Logical und Character
  4. Fallstricke und Best Practices bei der Typumwandlung
← Zurück zu R Academy