Tipos de Dados em R: numeric, character, logical (typeof e class)

Os Tipos de Dados em R

Todo valor em R tem um dos poucos tipos atômicos. Quatro deles fazem quase todo o trabalho:

• double - números decimais: 3.14, -2, 1e6. É isso que R chama de "numeric", e é o padrão para qualquer número que você digitar.
• integer - números inteiros armazenados de forma exata, escritos com o sufixo L: 42L.
• character - texto entre aspas: "hello".
• logical - os dois valores de verdade TRUE e FALSE (mais NA, o valor ausente - veja valores ausentes).

Há também o complex (2 + 3i) para o ocasional cálculo de processamento de sinais; dá para passar anos sem precisar dele. typeof() diz qual tipo um valor tem:

cat(typeof(3.14), "\n")
cat(typeof(42L), "\n")
cat(typeof("hello"), "\n")
cat(typeof(TRUE), "\n")
cat(typeof(2 + 3i), "\n")

Repare na primeira linha: um número simples é um double mesmo que pareça inteiro. typeof(42) é "double"; apenas 42L é um integer. Na análise do dia a dia a diferença raramente importa - R converte entre eles silenciosamente - mas ela explica boa parte das saídas confusas de typeof().

typeof() vs class(): Por Que Eles Discordam

R tem duas funções que parecem responder "o que é isto?", e elas respondem a perguntas sutilmente diferentes.

• typeof() informa o tipo de armazenamento: como o valor está na memória.
• class() informa o tipo comportamental: o rótulo que o despacho de métodos do R usa para decidir, por exemplo, qual print ou summary executar.

Para valores simples, as respostas diferem apenas no vocabulário:

x <- 3.14
cat(typeof(x), "\n")
cat(class(x), "\n")

typeof() diz double (o armazenamento), class() diz numeric (o comportamento). Para estruturas, a diferença aumenta:

m <- matrix(1:4, nrow = 2)
cat(typeof(m), "\n")
print(class(m))

A matriz é armazenada como um simples vetor de integers, mas se comporta como uma matriz - é o class() que diz ao R para imprimi-la como uma grade. A mesma divisão aparece em data frames (typeof diz "list", class diz "data.frame") e em datas (typeof diz "double", class diz "Date").

A regra prática: use class() quando quiser saber o que algo é no sentido cotidiano, e typeof() quando estiver depurando o que R está fazendo por baixo dos panos.

Verificando Tipos com is.*()

Cada tipo tem um predicado correspondente que retorna TRUE ou FALSE - útil dentro de funções que precisam validar sua entrada:

x <- 10
cat(is.numeric(x), is.character(x), is.logical(x), "\n")

Uma armadilha que vale conhecer: is.numeric() é TRUE para doubles e integers (ambos são números), mas is.integer() verifica o armazenamento, então é FALSE para um simples 42:

cat(is.numeric(42L), "\n")
cat(is.integer(42), "\n")
cat(is.integer(42L), "\n")

Se você já se surpreendeu com is.integer(7) ser FALSE para um número que é obviamente inteiro no sentido matemático - o motivo é este. 7 é um double; 7L é um integer.

Convertendo Tipos com as.*()

A conversão explícita usa a família as.*, uma função por tipo de destino:

cat(as.numeric("3.5") + 1, "\n")
cat(as.integer(7.9), "\n")
cat(as.character(42), "\n")
cat(as.logical("TRUE"), "\n")

Dois comportamentos para lembrar. as.integer() trunca em direção ao zero em vez de arredondar - 7.9 vira 7. E quando uma conversão não faz sentido, R não lança um erro; ele retorna NA e emite um warning:

result <- as.numeric("abc")
print(result)

Execute isso e você verá NA mais um warning de "NAs introduced by coercion". Isso é genuinamente útil - converta uma coluna inteira de texto bagunçado para números e as entradas não interpretáveis viram NA em vez de derrubar seu script - mas também significa que um NA silencioso pode se infiltrar nos seus dados. Quando uma conversão importa, verifique se surgiram novos NAs depois.

Logicals convertem de e para números do jeito que você esperaria: as.numeric(TRUE) é 1, as.logical(0) é FALSE. É por isso que sum() de um vetor logical conta os TRUEs:

passed <- c(TRUE, TRUE, FALSE, TRUE)
cat(sum(passed), "out of", length(passed), "\n")

Coerção Implícita: A Regra do Tipo Único para Vetores

Um vetor atômico em R só pode conter um tipo. Combine valores mistos com c() e R promove tudo silenciosamente para o tipo mais flexível presente, seguindo uma escada fixa:

logical → integer → double → character

print(c(TRUE, FALSE, 2L))
print(c(1L, 2L, 3.5))
print(c(1, 2, "three"))

Os logicals viraram 1 e 0, os integers viraram doubles, e na última linha tudo virou texto - character sempre vence, porque qualquer valor pode ser escrito como string. Você pode confirmar com typeof():

cat(typeof(c(TRUE, 1L)), "\n")
cat(typeof(c(1L, 2.5)), "\n")
cat(typeof(c(1, "a")), "\n")

Coerção é a fonte número um dos bugs de "por que minha coluna virou texto?": uma única string "N/A" perdida em uma coluna de números coage o vetor inteiro para character. Quando isso acontecer, corrija primeiro o valor problemático e depois converta de volta com as.numeric().

O Que Você Leva Daqui

• Quatro tipos que fazem o trabalho pesado: double ("numeric"), integer (42L), character, logical.
• typeof() = como é armazenado; class() = como se comporta. 3.14 é um double que se comporta como numeric.
• Verifique com is.numeric() e companhia; converta com as.numeric() e companhia - conversões que falham dão NA com um warning, não um erro.
• Vetores contêm um único tipo; misturar coage ao longo de logical → integer → double → character.

A seguir: um olhar mais de perto sobre os tipos numéricos - arredondamento, funções matemáticas e as surpresas de ponto flutuante que toda linguagem compartilha.