PricingLoginStart free
R Academy · Les

Overzicht van het typesysteem van R

Begrijp de typen double, integer, character, logical en complex.

Les 1 van 413 stappen

Overzicht van het typesysteem van R is een gratis R Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject R Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus R Academy bevat in totaal 4 lessen.

Het typesysteem van R

R heeft een uitgebreid typesysteem. Elk object heeft een class (categorie op hoog niveau) en een type (opslagmodus op laag niveau). Als je beide begrijpt, kun je correcte, efficiënte code schrijven en fouten met betrekking tot types opsporen.

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

class(x) geeft de categorie op hoog niveau terug die wordt gebruikt door het objectgeoriënteerde systeem van R (bijvoorbeeld 'integer', 'numeric', 'matrix'). typeof(x) geeft het C-opslagtype op laag niveau terug (bijvoorbeeld '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() — numerieke controle

is.numeric(x) geeft TRUE terug voor zowel waarden van het type integer als double (en voor numerieke matrices). De functie controleert het numerieke supertype, niet de specifieke opslagmodus.

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() versus is.double()

is.integer() controleert specifiek op opslag als integer (gemaakt met het achtervoegsel L of met as.integer()). is.double() controleert op opslag als floating-pointwaarde (double). Beide zijn deelverzamelingen van numeric.

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() — tekenreekscontrole

is.character(x) geeft TRUE terug als x een character-vector (tekenreeksvector) is. Gebruik dit om invoer te valideren die tekst moet zijn, of om onderscheid te maken tussen numerieke en character-typen van NA.

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() — Booleaanse controle

is.logical(x) geeft TRUE terug als x logical (Booleaanse) waarden bevat. Let op: het niet-getypeerde NA is standaard een logical-waarde.

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

De typehiërarchie van R

De atomische types van R vormen een hiërarchie van eenvoudig naar complex: logical < integer < double < complex < character. Wanneer je types in een vector combineert, converteert R alle elementen naar het meest complexe aanwezige type.

# 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

Types programmatisch inspecteren

Je kunt functies schrijven die types inspecteren om een lijst met objecten te controleren. Door class(), typeof() en length() te combineren, krijg je een uitgebreid overzicht van de structuur van elk object.

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() en mode()

storage.mode(x) lijkt op typeof(x), maar gebruikt de S3-naamgevingsconventie (de functie geeft bijvoorbeeld 'double' terug in plaats van 'double'). mode(x) geeft een iets grovere indeling terug, waarbij integer en double samen worden genomen als 'numeric'.

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

Types van lijsten en dataframes inspecteren

Voor complexere objecten zoals lijsten en dataframes past sapply(df, class) class() toe op elke kolom. Dit geeft een benoemde vector met kolomtypes terug: een snelle manier om het schema van een dataframe te controleren.

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

Samenvatting van het typesysteem

Hier volgt een snel overzicht van de hulpmiddelen van R voor type-inspectie:

  • class(x) — S3-classenaam op hoog niveau
  • typeof(x) — C-opslagtype op laag niveau
  • is.numeric(x) — TRUE voor integer of double
  • is.integer(x) — TRUE alleen voor integer-opslag
  • is.double(x) — TRUE alleen voor double (floating-point)
  • is.character(x) — TRUE voor tekenreeksen
  • is.logical(x) — TRUE voor 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), '
')

Korte controle

Wat geeft is.numeric(5L) terug in R?

Beantwoord dit in de interactieve les

Samenvatting: het typesysteem van R

Goed gedaan! Dit zijn de belangrijkste punten uit deze les:

  • class(x) geeft het type op hoog niveau terug; typeof(x) geeft het opslagtype op laag niveau terug
  • is.numeric() is TRUE voor zowel integers als doubles
  • is.integer() en is.double() maken onderscheid tussen de twee numerieke subtypes
  • De typehiërarchie van R (laag → hoog): logical → integer → double → complex → character
  • Het combineren van types in een vector leidt automatisch tot conversie naar het hoogste type
  • sapply(df, class) controleert alle kolomtypes in een dataframe
# 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')
Gratis beginnen

Leer R met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
43
Lessen
159
Gratis beginnen met lerenBekijk de volledige cursus

Veelgestelde vragen

Is de les “Overzicht van het typesysteem van R” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad R Academy, waaronder “Overzicht van het typesysteem van R”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus R Academy bevat in totaal 4 lessen.

Wat leer ik in “Overzicht van het typesysteem van R”?

Begrijp de typen double, integer, character, logical en complex. Je oefent met R Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met R Academy te beginnen?

Ervaring vooraf is niet nodig. R Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Overzicht van het typesysteem van R”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over R Academy?

Ja. Elke les over R Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. Overzicht van het typesysteem van R
  2. Tussen numerieke typen converteren
  3. Conversie van logical en character
  4. Valkuilen en best practices bij coercion
← Terug naar R Academy