0Pricing
R Academy · Lección

Problemas y buenas prácticas de coerción

Identifique y evite la pérdida de datos causada por una coerción implícita inesperada.

Problemas y buenas prácticas de coerción es una lección gratuita de R Academy en CoddyKit. Esta es la lección 4 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.

¿Qué es la coerción implícita?

La coerción implícita ocurre automáticamente cuando R combina tipos diferentes. R convierte silenciosamente todos los elementos al tipo más complejo presente en un vector, siguiendo la jerarquía: logical < integer < double < complex < character.

# Combining different types triggers implicit coercion
v1 <- c(TRUE, 1L, 2.5)   # logical < integer < double => double
v2 <- c(1, 2, 'three')    # double < character => character
v3 <- c(FALSE, 0L, 0.0)   # all become double

cat('c(TRUE,1L,2.5)   :', v1, '| typeof:', typeof(v1), '
')
cat('c(1,2,"three")   :', v2, '| typeof:', typeof(v2), '
')
cat('c(FALSE,0L,0.0)  :', v3, '| typeof:', typeof(v3), '
')

Coerción de logical a integer

Cuando un vector lógico se coloca en un contexto de enteros, TRUE se convierte en 1L y FALSE en 0L. Esto es intencional en R y se utiliza en expresiones como sum(condition_vector).

flags <- c(TRUE, FALSE, TRUE, TRUE, FALSE)
result <- c(flags, 10L)
cat('c(logicals, 10L):', result, '
')       # 1 0 1 1 0 10
cat('typeof:          ', typeof(result), '
') # integer

# Adding an integer to a logical vector
cat('flags + 1L:', flags + 1L, '
')  # 2 1 2 2 1

Coerción de integer a double

Al combinar enteros y números de doble precisión, todo se convierte a double. Normalmente esto no causa problemas, ya que los valores se conservan, pero puede hacer que las comprobaciones con identical() fallen inesperadamente.

int_vec <- c(1L, 2L, 3L)
dbl_val <- 1.5

result <- c(int_vec, dbl_val)
cat('Combined:', result, '
')
cat('typeof:', typeof(result), '
')  # double

# identical() is type-sensitive
cat('identical(1L, 1.0):', identical(1L, 1.0), '
')  # FALSE!
cat('1L == 1.0:         ', 1L == 1.0, '
')           # TRUE (value equal)

El peligro: los números se convierten en caracteres

La coerción más peligrosa es de numérico a carácter. Una vez que un número se convierte en una cadena, ya no es posible hacer operaciones aritméticas con él. R lo hace silenciosamente cuando se mezcla una cadena con un vector numérico.

# One string contaminates a whole numeric vector!
measurements <- c(22.1, 19.8, 'missing', 25.1, 17.3)
cat('Values:', measurements, '
')
cat('typeof:', typeof(measurements), '
')  # character!

# Now arithmetic fails
result <- suppressWarnings(as.numeric(measurements))
cat('After as.numeric:', result, '
')   # 22.1 19.8 NA 25.1 17.3
cat('NA introduced:  ', sum(is.na(result)), '
')

Peligro de la coerción de factores

Internamente, los factores almacenan las categorías como códigos enteros. Si convierte directamente un factor a numérico, obtiene los códigos enteros (1, 2, 3, ...), no los valores originales. Esta es una fuente muy conocida de errores.

salary_factor <- factor(c('50000', '75000', '60000', '80000'))
cat('Factor levels:', levels(salary_factor), '
')

# WRONG: gives integer codes 1,2,3,4
wrong <- as.numeric(salary_factor)
cat('Wrong (codes):  ', wrong, '
')  # 1 3 2 4 (alphabetical order)

# CORRECT: convert via character first
correct <- as.numeric(as.character(salary_factor))
cat('Correct values: ', correct, '
')  # 50000 75000 60000 80000

as.integer('abc') — NA con advertencia

Convertir una cadena no numérica a integer o double produce NA y genera una advertencia: 'NAs introduced by coercion'. Siempre debe gestionar este caso al analizar entradas del usuario o archivos de datos.

# Conversion of non-numeric strings produces NA + warning
bad_inputs <- c('42', 'hello', '3.14', 'N/A', '100')
cat('Input:', bad_inputs, '
')

numeric_vals <- suppressWarnings(as.numeric(bad_inputs))
cat('Converted:', numeric_vals, '
')  # 42 NA 3.14 NA 100
cat('NAs introduced:', sum(is.na(numeric_vals)), '
')

# Check validity before converting
can_convert <- !is.na(suppressWarnings(as.numeric(bad_inputs)))
cat('Valid numerics:', bad_inputs[can_convert], '
')

Comprobar antes de convertir

La mejor práctica es validar los datos antes de convertirlos. Escriba una función auxiliar que compruebe si una cadena se puede analizar de forma segura como número y convierta únicamente las que superen la comprobación.

is_numeric_string <- function(x) {
  !is.na(suppressWarnings(as.numeric(x)))
}

test_strings <- c('3.14', 'abc', '-5', 'Inf', '1e3', 'TRUE', '0')
cat('String     | Is numeric?
')
for (s in test_strings) {
  cat(sprintf('%-10s | %s
', s, is_numeric_string(s)))
}

La coerción en c() es irreversible

Una vez que los tipos se convierten dentro de una llamada a c(), se pierden los tipos originales. Para datos de tipos mixtos, use una list en lugar de un vector: las listas conservan el tipo de cada elemento de forma independiente.

# Vector: coerces to character
v <- c(42, 'hello', TRUE)
cat('Vector:', v, '| typeof:', typeof(v), '
')  # character!

# List: preserves types
l <- list(42, 'hello', TRUE)
cat('List element types:', sapply(l, typeof), '
')  # double, character, logical

Coerción implícita en operaciones aritméticas

Las operaciones aritméticas convierten implícitamente los valores lógicos a numéricos. Saberlo le ayuda a escribir código conciso, pero tenga cuidado: puede ocultar errores de tipo si pasa accidentalmente un valor lógico donde se espera un número.

# TRUE/FALSE are automatically treated as 1/0
x <- TRUE
y <- FALSE
cat('TRUE + 1:   ', x + 1, '
')   # 2
cat('FALSE * 10: ', y * 10, '
')  # 0
cat('TRUE / 4:   ', x / 4, '
')   # 0.25

# Counting with sum
pass_flags <- c(TRUE, FALSE, TRUE, TRUE, FALSE)
cat('Passing count:', sum(pass_flags), '
')  # 3

Mejor práctica: conversión explícita

El enfoque más seguro es convertir los tipos explícitamente con las funciones as.*() en lugar de depender de la coerción implícita. Así sus intenciones quedan claras y los problemas salen a la luz cuanto antes.

# Implicit (works but hides intent)
counts <- c(TRUE, FALSE, TRUE, TRUE, FALSE)
total_implicit <- sum(counts)  # relies on logical-to-int coercion

# Explicit (clearer intent)
counts_int <- as.integer(counts)
total_explicit <- sum(counts_int)

cat('Implicit:  ', total_implicit, '
')
cat('Explicit:  ', total_explicit, '
')
cat('Both equal:', total_implicit == total_explicit, '
')

Resumen de las reglas de coerción

Reglas y problemas clave de la coerción:

  • Jerarquía: logical → integer → double → complex → character (gana el tipo de mayor nivel)
  • Peligro de los factores: use as.numeric(as.character(f)), nunca as.numeric(f)
  • Contaminación por cadenas: una cadena en un vector numérico convierte todo el vector
  • NA con advertencia: una cadena no numérica → NA (use suppressWarnings() cuando sea lo esperado)
  • Mejor práctica: use conversiones explícitas con as.*(); use listas para tipos mixtos
# The coercion hierarchy demonstrated
cat('logical+integer : ', typeof(c(TRUE, 1L)), '
')   # integer
cat('integer+double  : ', typeof(c(1L, 1.5)), '
')   # double
cat('double+character: ', typeof(c(1.5, 'a')), '
')  # character

Comprobación rápida

¿Cuál es la forma segura de convertir un factor a valores numéricos en R?

Repaso: problemas de la coerción

¡Excelente! Estas son las conclusiones principales de la lección:

  • R realiza coerción implícita cuando se mezclan tipos: logical → integer → double → character
  • Una cadena en un vector numérico convierte todo el vector a character
  • Los factores convertidos con as.numeric() producen códigos enteros; use as.numeric(as.character(f)) en su lugar
  • Las cadenas no numéricas producen NA con una advertencia al pasarlas a as.numeric()
  • Use listas, no vectores, para almacenar datos de tipos mixtos sin coerción
  • Prefiera la conversión explícita con as.*() para dejar claras las intenciones de tipo
# Final: safe factor-to-numeric conversion
price_factor <- factor(c('29.99', '14.99', '49.99', '9.99'))
cat('Factor levels:', levels(price_factor), '
')

# Wrong way
cat('WRONG (codes):  ', as.numeric(price_factor), '
')
# Right way
cat('CORRECT (vals): ', as.numeric(as.character(price_factor)), '
')

Preguntas frecuentes

¿La lección «Problemas y buenas prácticas de coerción» es gratis?

Sí — el texto completo de «Problemas y buenas prácticas de coerción» 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 «Problemas y buenas prácticas de coerción»?

Identifique y evite la pérdida de datos causada por una coerción implícita inesperada. 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 4 de 4.

¿Cuánto tiempo toma la lección «Problemas y buenas prácticas de coerción»?

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