0Pricing
R Academy · Leçon

Vue d’ensemble du système de types de R

Comprenez les types double, integer, character, logical et complex.

Vue d’ensemble du système de types de R 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.

Le système de types de R

R possède un système de types riche. Chaque objet possède une classe (catégorie de haut niveau) et un type (mode de stockage de bas niveau). Comprendre ces deux notions vous aide à écrire du code correct et efficace, ainsi qu’à déboguer les erreurs liées aux types.

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

class(x) renvoie la catégorie de haut niveau utilisée par le système orienté objet de R (par exemple, 'integer', 'numeric', 'matrix'). typeof(x) renvoie le type de stockage C de bas niveau (par exemple, '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() — Vérification numérique

is.numeric(x) renvoie TRUE pour les valeurs integer comme pour les valeurs double (ainsi que pour les matrices numériques). Cette fonction vérifie le supertype numérique, et non le mode de stockage précis.

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

is.integer() vérifie spécifiquement le stockage integer (créé avec le suffixe L ou as.integer()). is.double() vérifie le stockage en virgule flottante (double). Ces deux types sont des sous-ensembles de 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() — Vérification des chaînes

is.character(x) renvoie TRUE si x est un vecteur character (chaînes). Utilisez cette fonction pour valider les entrées qui doivent être du texte ou pour distinguer les types NA numériques des types NA character.

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() — Vérification booléenne

is.logical(x) renvoie TRUE si x contient des valeurs logical (booléennes). Notez que NA sans type explicite est par défaut une valeur logical.

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

Hiérarchie des types de R

Les types atomiques de R forment une hiérarchie, du plus simple au plus complexe : logical < integer < double < complex < character. Lorsque vous mélangez des types dans un vecteur, R convertit tous les éléments vers le type le plus complexe présent.

# 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

Inspection programmatique des types

Vous pouvez écrire des fonctions d’inspection des types pour examiner une liste d’objets. La combinaison de class(), typeof() et length() fournit un résumé complet de la structure de n’importe quel objet.

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

storage.mode(x) est similaire à typeof(x), mais utilise la convention de nommage S3 (par exemple, renvoie 'double' au lieu de 'double'). mode(x) renvoie un regroupement légèrement moins précis, qui réunit integer et double sous '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

Inspection des types pour les listes et les trames de données

Pour les objets plus complexes, comme les listes et les trames de données, sapply(df, class) applique class() à chaque colonne et fournit un vecteur nommé des types de colonnes : c’est un moyen rapide de vérifier le schéma d’une trame de données.

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

Résumé du système de types

Voici une référence rapide des outils d’inspection des types de R :

  • class(x) — nom de classe S3 de haut niveau
  • typeof(x) — type de stockage C de bas niveau
  • is.numeric(x) — TRUE pour integer ou double
  • is.integer(x) — TRUE uniquement pour le stockage integer
  • is.double(x) — TRUE uniquement pour le stockage double (à virgule flottante)
  • is.character(x) — TRUE pour les chaînes
  • is.logical(x) — TRUE pour 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), '
')

Vérification rapide

Que renvoie is.numeric(5L) dans R ?

Récapitulatif : le système de types de R

Excellent travail ! Voici les points essentiels de cette leçon :

  • class(x) renvoie le type de haut niveau ; typeof(x) renvoie le type de stockage de bas niveau
  • is.numeric() vaut TRUE pour les integer comme pour les double
  • is.integer() et is.double() permettent de distinguer les deux sous-types numériques
  • Hiérarchie des types de R (du plus bas au plus haut) : logical → integer → double → complex → character
  • Mélanger des types dans un vecteur déclenche automatiquement une conversion vers le type le plus élevé
  • sapply(df, class) vérifie tous les types de colonnes d’une trame de données
# 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')

Questions Fréquemment Posées

La leçon « Vue d’ensemble du système de types de R » est-elle gratuite ?

Oui — le texte complet de « Vue d’ensemble du système de types de R » 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 « Vue d’ensemble du système de types de R » ?

Comprenez les types double, integer, character, logical et complex. 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 « Vue d’ensemble du système de types de R » ?

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. Vue d’ensemble du système de types de R
  2. Convertir entre les types numériques
  3. Conversions logique et caractère
  4. Pièges de la coercition et bonnes pratiques
← Retour à R Academy