# Operator in R: Introdução aos operadores R

Operadores funcionam como blocos de construção em qualquer linguagem de programação. Não poderia ser diferente, portanto, na linguagem de programação R. Use operadores R para realizar operações matemáticas, desempenhar cálculos aritméticos e analisar comparações e expressões lógicas.

## O que é *operator in R*?

*Operator in R*, ou operador R, nada mais é que um **símbolo especial ou string** usado para desempenhar operações com valores e variáveis. Tais operações incluem cálculos aritméticos, comparações, atribuições e ações semelhantes. Assim, operadores R têm papel fundamental na transformação, na manipulação e na análise de dados, funcionando como a base da programação em R.

Dica A linguagem de programação R é adequada a diversos tipos de projetos. Para publicá-los, você precisará de um espaço web. Conheça o [Webspace](https://www.ionos.com/hosting/webspace "Webspace — IONOS") da IONOS e descubra as possibilidades que essa versátil hospedagem tem a oferecer.

## Tipos de *operator in R*

Operadores costumam ser divididos em **grupos de funcionalidade**. Apesar de básica, a lista abaixo apresenta os principais tipos de operadores R.

- **Operadores aritméticos**: Usados para cálculos aritméticos.
- **Operadores lógicos**: Usados para comparar valores de verdade e avaliar expressões lógicas — eles retornam valores de verdade.
- **Operadores bit a bit**: Usados para manipular bits em um número.
- **Operadores de atribuição**: Usados para atribuir valores a variáveis.
- **Operadores de comparação**: Usados para comparar valores e criar expressões lógicas.

Ao contrário de outras linguagens de programação, **a linguagem R não possui operadores de incremento e decremento** definidos. Caso você venha a precisar dessa funcionalidade em *loops for R* ou [*loops while R*](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/r-while-loop/), realize uma adição ou uma subtração com 1.

## *R operator* aritmético

Operadores aritméticos são usados para desempenhar **cálculos matemáticos**, inclusive de aritmética básica.

<table>
  <thead>
    <tr>
      <th><strong>Operador</strong></th>
      <th><strong>Descrição</strong></th>
      <th><strong>Exemplo</strong></th>
      <th><strong>Resultado</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`+`</td>
      <td>Adição de números</td>
      <td>`5 + 3`</td>
      <td>`8`</td>
    </tr>
    <tr>
      <td>`-`</td>
      <td>Subtração de números</td>
      <td>`10 - 5`</td>
      <td>`5`</td>
    </tr>
    <tr>
      <td>`*`</td>
      <td>Multiplicação de números</td>
      <td>`3* 5`</td>
      <td>`15`</td>
    </tr>
    <tr>
      <td>`/`</td>
      <td>Divisão de números</td>
      <td>`10 / 2`</td>
      <td>`5`</td>
    </tr>
    <tr>
      <td>`%%`</td>
      <td>Módulo (retorna o resto de uma divisão)</td>
      <td>`10%% 4`</td>
      <td>`2`</td>
    </tr>
    <tr>
      <td>`%/%`</td>
      <td>Divisão inteira</td>
      <td>`11 %/% 3`</td>
      <td>`3`</td>
    </tr>
    <tr>
      <td>`^`</td>
      <td>Exponenciação</td>
      <td>`2 ^ 3`</td>
      <td>`8`</td>
    </tr>
  </tbody>
</table>

### Exemplo de operador R aritmético em código

```R
a <- 7
b <- 3
addition <- a + b
subtraction <- a - b
multiplication <- a * b
division <- a / b
modulo <- a %% b
Integer division <- a %/% b
exponentiation <- 2^3
```

## *R operator* lógico

Operadores lógicos são usados para **comparar valores de verdade** e avaliar expressões lógicas. Eles sempre retornam um valor de verdade como resultado, que pode ser *TRUE* (verdadeiro) ou *FALSE* (falso).

<table>
  <thead>
    <tr>
      <th><strong>Operador</strong></th>
      <th><strong>Descrição</strong></th>
      <th><strong>Exemplo</strong></th>
      <th><strong>Resultado</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`&`</td>
      <td>AND lógico: Retorna *TRUE* se os dois valores forem verdadeiros</td>
      <td>`TRUE & FALSE`</td>
      <td>`FALSE`</td>
    </tr>
    <tr>
      <td>`</td><td>`</td>
      <td>OR lógico (com *R pipe operator*): Retorna *TRUE* se um dos dois valores for verdadeiro</td>
      <td>`TRUE </td></tr><tr><td>`!`</td><td>NOT lógico: Inverte o valor de verdade </td><td>`!TRUE`</td><td>`FALSE`</td>
    </tr>
  </tbody>
</table>

### Exemplo de operador R lógico em código

```R
x <- TRUE
y <- FALSE
 
and_operator <- x & y
or_operator <- x | y
not_operator <- !x
```

## *R operator* bit a bit

Operadores bit a bit permitem que você manipule os bits de um número. Para entender como esses operadores funcionam, é necessário algum conhecimento mais aprofundado sobre sistema binário, o sistema numérico de base 2.

<table>
  <thead>
    <tr>
      <th><strong>Operador</strong></th>
      <th><strong>Descrição</strong></th>
      <th><strong>Exemplo</strong></th>
      <th><strong>Resultado</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`bitwAnd`</td>
      <td>AND bit a bit</td>
      <td>`bitwAnd(5,3)`</td>
      <td>`1`</td>
    </tr>
    <tr>
      <td>`bitwOr`</td>
      <td>OR bit a bit</td>
      <td>`bitwOr(5,3)`</td>
      <td>`7`</td>
    </tr>
    <tr>
      <td>`bitwXor`</td>
      <td>XOR bit a bit (OR exclusivo)</td>
      <td>`bitwXor(5,3)`</td>
      <td>`6`</td>
    </tr>
    <tr>
      <td>`bitwNot`</td>
      <td>NOT bit a bit</td>
      <td>`bitwNot(5)`</td>
      <td>`-6`</td>
    </tr>
    <tr>
      <td>`bitwShiftL`</td>
      <td>*Shift* bit a bit para a esquerda -&gt; Deslocamento de bits para a esquerda a partir do número de bits especificado no segundo parâmetro</td>
      <td>`bitwShiftL(5, 1)`</td>
      <td>`10`</td>
    </tr>
    <tr>
      <td>`bitwShiftR`</td>
      <td>*Shift* bit a bit para a direita -&gt; Deslocamento de bits para a direita a partir do número de bits especificado no segundo parâmetro</td>
      <td>`bitwShiftR(5, 1)`</td>
      <td>`2`</td>
    </tr>
  </tbody>
</table>

### Exemplo de operador R bit a bit em código

```R
a <- 5
b <- 3
bitwise_and <- bitwAnd(a, b)
bitwise_or <- bitwOr(a, b)
bitwise_xor <- bitwXor(a, b)
bitwise_not <- bitwNot(a)
Slide left <- bitwShiftL(a, 1)
Slide right <- bitwShiftR(a, 1)
```

## *R operator* de comparação

Operadores R de comparação são usados para comparar valores. Eles retornam um valor booleano *TRUE* ou *FALSE*.

<table>
  <thead>
    <tr>
      <th><strong>Operador</strong></th>
      <th><strong>Descrição</strong></th>
      <th><strong>Exemplo</strong></th>
      <th><strong>Resultado</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`==`</td>
      <td>Compara dois valores quanto à similaridade</td>
      <td>`5 == 3`</td>
      <td>`FALSE`</td>
    </tr>
    <tr>
      <td>`!=`</td>
      <td>Compara dois valores quanto à diferença</td>
      <td>`5 != 3`</td>
      <td>`TRUE`</td>
    </tr>
    <tr>
      <td>`<`</td>
      <td>Compara se o valor à esquerda é menor que o valor à direita</td>
      <td>`5 < 3`</td>
      <td>`FALSE`</td>
    </tr>
    <tr>
      <td>`>`</td>
      <td>Compara se o valor à esquerda é maior que o valor à direita</td>
      <td>`5 &gt; 3`</td>
      <td>`TRUE`</td>
    </tr>
    <tr>
      <td>`<=`</td>
      <td>Compara se o valor à esquerda é menor ou igual ao valor à direita</td>
      <td>`5 <= 3`</td>
      <td>`FALSE`</td>
    </tr>
    <tr>
      <td>`>=`</td>
      <td>Compara se o valor à esquerda é maior ou igual ao valor à direita</td>
      <td>`5 &gt;= 3`</td>
      <td>`TRUE`</td>
    </tr>
  </tbody>
</table>

### Exemplo de operador R de comparação em código

```R
x <- 5
y <- 3
equal <- x == y
not_equal <- x != y
less_than <- x < y
more_than <- x > y
less_than_or_equal_to <- x <= y
more_than_or_equal_to <- x >= y
```

## *R operator* de atribuição

Operadores de atribuição são usados para **atribuir valores específicos a variáveis**, sendo, portanto, essenciais a qualquer linguagem de programação. Existem diversos operadores R de atribuição, sendo o operador `<-` o mais usado.

<table>
  <thead>
    <tr>
      <th><strong>Operador</strong></th>
      <th><strong>Descrição</strong></th>
      <th><strong>Exemplo</strong></th>
      <th><strong>Resultado</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`=`</td>
      <td>Operador de atribuição de nível superior usado principalmente por funções, para atribuir argumentos</td>
      <td>`matrix(1, nrow = 2)`</td>
      <td>Após a execução, nenhuma variável se chamará `nrow`.</td>
    </tr>
    <tr>
      <td>`<-`</td>
      <td>Operador de atribuição em seta usado para atribuir valores numéricos simples ou complexos (como [listas R](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/r-list/)) a variáveis; também permite criar novos objetos</td>
      <td>`matrix(1, nrow <- 2)`</td>
      <td>Após a execução, uma variável se chamará `nrow`.</td>
    </tr>
    <tr>
      <td>`<<-`</td>
      <td>Operador de atribuição utilizado em funções que busca em um ambiente; pesquisa definições de variáveis já existentes ou cria uma nova variável no ambiente</td>
      <td>`a <<- 1`</td>
      <td>Se *a* ja existir, *a* passará a ter o valor de 1; do contrário, *a* será criado, com o valor de 1.</td>
    </tr>
  </tbody>
</table>

### Exemplo de operador R de atribuição em código

```R
matrix(1, nrow=2)
b <- 3
test <- function() {
    a <<- 1
}
```


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