# Estrutura e tipos de dados em R

Assim como outras linguagens de programação, a programação em R suporta diversos tipos de dados, usados para a manipulação e o processamento de informações. Conheça as principais estruturas e tipos de dados em R.

## Por que existem diferentes tipos de dados em R?

Programar quase sempre envolve o processamento de dados. Então, para que esses dados possam ser armazenados de forma lógica, cada linguagem oferece possibilidades próprias. Em R, números e caracteres são exemplos de tipos de dados que programadores podem usar para organizar informações de um jeito eficiente.

Tipos de dados diferentes desempenham funções e operações específicas. Por exemplo, variados [operadores em R](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/operator-in-r/ "Operadores em R") são destinados a funcionar com tipos de dados próprios. Operadores ajudam programadores a **processar dados com mais eficiência**, aumentando a eficácia de um código.

## Principais tipos de dados em R com exemplos

A linguagem de programação R suporta diversos tipos de dados. Se você também está [aprendendo a programar](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/aprender-programacao-introducao-basica/) em outras linguagens, talvez já tenha entrado em contato com alguns tipos de dados também usados em R. Para verificar o tipo de dado de uma variável nessa linguagem, faça uso do [comando em R](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/commands-in-r/ "Comandos em R") `class()`. Ao inserir uma variável entre os parênteses da função `class`, o tipo de dado dessa variável é especificado.

### Dados numéricos

Dados numéricos são um dos **tipos de dados mais básicos em R**. Obviamente, eles nada mais são que valores numéricos. Entre os dados numéricos estão o tipo *numeric*, usado para números reais; *integer*, aplicado aos inteiros; e *complex*, que faz referência aos números complexos, que contêm um componente imaginário:

```R
x <- 3.14
y <- 42
z <- 3 + 2i
print(class(x))
print(class(y))
print(class(z))
```

Observe o resultado gerado pelo exemplo código acima:

```none
"numeric"
"numeric"
"complex"
```

Talvez você esteja se perguntando por que esse código apresentou o tipo de dado *numeric* duas vezes, apesar de a variável *y* ser um número inteiro. Isso ocorreu porque **inteiros são sempre considerados *numeric* pela linguagem de programação R**. Para que o interpretador classifique um número inteiro como do tipo *integer*, você deve adicionar um *L* ao final dele, como no exemplo abaixo:

```R
y <- 42L
print(class (y))
```

Assim, quando a função for chamada, ela apresentará como resultado o tipo *integer*, em vez do tipo *numeric*:

```none
"integer"
```

### Dados caracteres

Em textos e caracteres, você pode usar o tipo de dado *character* (caractere). Dados que correspondem a esse tipo são especificados por [strings em R](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/r-string/ "Como criar e usar strings em R") e separados por **aspas simples ou duplas**:

```R
x <- "Olá mundo!"
y <- 'Hello world!'
print(class(x))
print(class(y))
```

Você também pode usar a função `class()` para identificar o tipo de dado das variáveis:

```none
"character"
"character"
```

### Dados lógicos

As variáveis que pertencem ao tipo de dado *logical* (lógico) são classificadas pelo interpretador como `TRUE` (verdadeiras) ou `FALSE` (falsas). Elas permitem que condições ou expressões lógicas sejam formalizadas, algo que é necessário para se controlar o fluxo de execução de um programa:

```R
x <- TRUE
y <- FALSE
print(class(x))
print(class(y))
```

Note que o uso da função `class ()` no código acima classifica as duas variáveis como do tipo de dado *logical*:

```R
"logical"
"logical"
```

### Dados raw

Na linguagem de programação R, existe também um tipo de dado que possibilita a visualização de variáveis como uma sequência de bytes. Esse tipo de dado é chamado de *raw*. Para converter dados para o formato *raw*, faça uso da função `charToRaw()`. Para converter dados *raw* de volta ao formato original, use a função `rawToChar`.

O código a seguir mostra como converter uma string em uma sequência de bytes. Nele, a variável *y* pertence ao tipo de dado *raw*:

```R
x <- "Oi mundo!"
y <- charToRaw(x)
print(y)
print(class(y))
```

Inicialmente, o código gerou uma sequência de bytes hexadecimal. Ao obtermos essa sequência de bytes, chamamos a função `class()`, que exibe o tipo de dado da variável *y*:

```R
48 61 6c 6c 6f 20 57 65 6c 74 21
"raw"
```

Nota Também é possível alterar tipos de dados na linguagem de programação R, e muitas dessas alterações são simples de serem realizadas. Por exemplo, em uma string que representa um número (como “42”), basta que você adicione um “0” para que esta seja convertida do tipo de dado *character* para o tipo de dado *numeric*.

## Estruturas de dados em R

Além dos tipos de dados básicos abordados por este tutorial, ainda existem várias outras estruturas na linguagem de programação R que ajudam programadores a melhor organizarem os dados dos seus códigos. Essas estruturas, contudo, são **mais complexas que tipos de dados simples**. Ao contrário dos tipos de dados apresentados pelos exemplos, tipos de dados mais complexos, como o dataframe R, costumam ser multidimensionais. Para trabalhar com eles, considere reunir elementos de diferentes tipos de dados em listas (*R data list*).

Dica Está desenvolvendo alguma aplicação com a linguagem de programação R? O [Webhosting](https://www.ionos.com/hosting/web-hosting "Webhosting: Get your project online — IONOS") da IONOS proporciona a você o espaço web ideal para o lançamento do seu projeto.


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/tipos-de-dados-r/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/tipos-de-dados-r/) for AI/LLM consumption.