0Pricing
R Academy · Lección

Descripción general del sistema de tipos de R

Comprenda los tipos double, integer, character, logical y complex.

Descripción general del sistema de tipos de R es una lección gratuita de R Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.

El sistema de tipos de R

R tiene un sistema de tipos muy completo. Cada objeto tiene una clase (categoría de alto nivel) y un tipo (modo de almacenamiento de bajo nivel). Comprender ambos le ayuda a escribir código correcto y eficiente, y a depurar errores relacionados con los tipos.

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

class(x) devuelve la categoría de alto nivel que utiliza el sistema orientado a objetos de R (por ejemplo, 'integer', 'numeric', 'matrix'). typeof(x) devuelve el tipo de almacenamiento de bajo nivel de C (por ejemplo, '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() — Comprobación numérica

is.numeric(x) devuelve TRUE tanto para valores integer como double (y para matrices numéricas). Comprueba el supertipo numérico, no el modo de almacenamiento específico.

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

is.integer() comprueba específicamente si el almacenamiento es de tipo entero (creado con el sufijo L o con as.integer()). is.double() comprueba si el almacenamiento es de coma flotante (double). Ambos son subconjuntos 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() — Comprobación de cadenas

is.character(x) devuelve TRUE si x es un vector de caracteres (cadenas). Úselo para validar entradas que deberían ser texto o para distinguir entre tipos NA numéricos y de caracteres.

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() — Comprobación booleana

is.logical(x) devuelve TRUE si x contiene valores lógicos (booleanos). Tenga en cuenta que NA sin tipo es un valor lógico de forma predeterminada.

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

Jerarquía de tipos de R

Los tipos atómicos de R forman una jerarquía, de los más simples a los más complejos: logical < integer < double < complex < character. Al mezclar tipos en un vector, R convierte todos los elementos al tipo más complejo presente.

# 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

Inspección programática de tipos

Puede escribir funciones de inspección de tipos para auditar una lista de objetos. Combinar class(), typeof() y length() proporciona un resumen completo de la estructura de cualquier objeto.

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

storage.mode(x) es similar a typeof(x), pero utiliza la convención de nombres de S3 (por ejemplo, devuelve 'double' en lugar de 'double'). mode(x) devuelve una agrupación ligeramente más general que combina integer y double como '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

Inspección de tipos para listas y marcos de datos

Para objetos más complejos, como listas y marcos de datos, sapply(df, class) aplica class() a cada columna y proporciona un vector con nombre de los tipos de columna: una forma rápida de auditar el esquema de un marco de datos.

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

Resumen del sistema de tipos

Aquí tiene una referencia rápida de las herramientas de inspección de tipos de R:

  • class(x) — nombre de la clase S3 de alto nivel
  • typeof(x) — tipo de almacenamiento de bajo nivel de C
  • is.numeric(x) — TRUE para integer o double
  • is.integer(x) — TRUE únicamente para almacenamiento integer
  • is.double(x) — TRUE únicamente para double (coma flotante)
  • is.character(x) — TRUE para cadenas
  • is.logical(x) — TRUE para 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), '
')

Comprobación rápida

¿Qué devuelve is.numeric(5L) en R?

Recapitulación: el sistema de tipos de R

¡Buen trabajo! Estas son las ideas clave de la lección:

  • class(x) devuelve el tipo de alto nivel; typeof(x) devuelve el tipo de almacenamiento de bajo nivel
  • is.numeric() es TRUE tanto para enteros como para doubles
  • is.integer() y is.double() distinguen los dos subtipos numéricos
  • Jerarquía de tipos de R (de menor a mayor): logical → integer → double → complex → character
  • Mezclar tipos en un vector activa la conversión automática al tipo de mayor nivel
  • sapply(df, class) audita todos los tipos de columna de un marco de datos
# 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')

Preguntas frecuentes

¿La lección «Descripción general del sistema de tipos de R» es gratis?

Sí — el texto completo de «Descripción general del sistema de tipos de R» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Descripción general del sistema de tipos de R»?

Comprenda los tipos double, integer, character, logical y complex. Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar R Academy?

No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Descripción general del sistema de tipos de R»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de R Academy?

Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Descripción general del sistema de tipos de R
  2. Conversión entre tipos numéricos
  3. Conversión de tipos logical y character
  4. Problemas y buenas prácticas de coerción
← Volver a R Academy