r_funcoes.qmd

---
engine: knitr
---

# Funções

[Status](convencoes.html#status-do-material) 🟦🟨🟨

## Criando Funções

Funções podem ser criadas através do comando `function`.

```{r}

fnSomar <- function(param1, param2) {
  param1 + param2
}

fnSomar(5, 8)
```

Para visualizar o código de uma função podemos usar seu nome sem os parênteses.

```{r}
fnSomar
```

### Argumentos - Valores Padrão

## Função x Ambiente

As funções possuem seus próprios ambientes. Abaixo uma função criada para exibir seu ambiente e seu ambiente 'pai'.

```{r}
fnExibirEnvs <- function() {
  print('Ambiente atual:')
  print(environment())
  
  print(paste(
    'Ambiente Pai:', 
    environmentName(parent.env(environment()
                               ))))
}

fnExibirEnvs()
```

### Objetos no Ambiente da Função

Objetos que são criados dentro de uma função existem apenas dentro do ambiente desta função. Abaixo um exemplo de variável criada dentro do ambiente da função e que não é acessível no **GlobalEnv**.

```{r, error = T}
fnTeste <- function(){
  y <- 15
  x <- 80
  ls()
}

fnTeste()
y
```

Objetos que existam no ambiente corrente não são alterados caso por estarem dentro do ambiente de fuma função. A variável **x** é inicializada com valor 10 no ambiente corrente. Ela pode ser acessada pela função mesmo não sendo informada em algum argumento.

```{r, error = T}
x <- 10

fnTeste2 <- function(){
  y <- 15
  x + y
}

fnTeste2()
y
x

```

Entretando, caso a variável **x** seja alterada no ambiente da função ela não é alterada no ambiente corrente.

```{r}
x <- 10

fnTeste3 <- function(){
  y <- 15
  x <- 80
  x + y
}

fnTeste3()
x
```

#### Operador de Super Atribuição (`<<-`)

Usando o operador de super atribuição `<<-` é possível alterar objetos que estejam fora do ambiente de uma função. Neste caso a variável **x** é atualizada no ambiente que está acima do ambiente da função. A variável **y** continua não existindo fora da função, porém agora a variável **x** é atualizada em ambos ambientes.

```{r, error = T}
ls(envir = globalenv())
x
fnTeste4 <- function(){
  y <- 15
  x <<- 80
  x + y
}

fnTeste4()
y
x

```

Apesar de, neste caso, produzirem o mesmo retorno, as funções `fnTeste3` e `fnTeste4` impactam de formas distintas o ambiente do R.

## Retorno

Na criação de funções, é possível utilizar o comando `return` a fim de definir o que será retornado pela função.

```{r}
fnRetorno <- function(){
  return('Este é o retorno da função!')
}
fnRetorno()
```

## Recursividade

Como outras linguagens de programação, R permite o uso recursivo de funções.

```{r}
fnRecursividade <- function(x){
  if(x > 100) return('X ultrapassou 100. Fim!')
  x <- x + 1
  print(paste('Valor atual de x:', x))
  fnRecursividade(x)
}

fnRecursividade(95)
```


### Buscar Ambiente Pai (Recursivamente)

Abaixo função que busca recursivamente os ambientes e seus 'pais' até que se chege no 'último' ambiente, o **R_EmptyEnv**.

```{r}

fnBuscarEnvsPai <- function(ambiente, nivel = 1){
 
    if(environmentName(ambiente)=="R_EmptyEnv"){
    return ('Ambiente informado é R_EmptyEnv. Fim da busca.')
    }
    
    marcacao <- ''
    for (i in 1:nivel){
      
      marcacao <- paste0(' ', marcacao)
    }
    
    writeLines(paste0(marcacao, '|-- ', environmentName(parent.env(ambiente))))

    nivel <- nivel + 1
    fnBuscarEnvsPai(parent.env(ambiente), nivel = nivel)

}
fnBuscarEnvsPai(globalenv())

```

## Funções Genéricas

Funções genéricas são funções que contém métodos associados. Os métodos são chamados de acordo com a classe do objeto informado.

Por exemplo a função print possui diversos métodos associados. Quando um **data.frame** é informado como argumento o R chama a função `print.data.frame`, ao passo que se o argumento da função for uma data o método invocado é `print.Date`.
```{r}
mtcars[1:2, 1:5] |> print.data.frame()
Sys.Date() |> print.Date()

# o mesmo que
mtcars[1:2, 1:5] |> print()
Sys.Date() |> print()
```

## Operadores Unários

A operador de soma `+` é na verdade uma função e é em geral utilizado na forma de operador unário, ou seja, recebe os valores da direita e da esquerda como seus argumentos. Veja o código que é reotrnado quando a função é chamada sem informação de argumentos e parênteses:

```{r}
`+`
```

Você poderia usar a função de somar de outra formacom a função `do.call` ou mesmo chamando esta com uso de cráses. Obviamente não é a forma mais sucinta, mas serve para demosntrar que `+` não passa de uma função como as demais.

```{r}
do.call(`+`, list(1,3))

`+`(8,7)
```

O mais interessante é que você também pode criar funções para serem usadas na forma de operador unário. Para isto basta criá-la com **%** ao início e ao fim do nome da função. Abaixo as duas formas de uso desta função:

```{r}
`%fnSomar2%`<- function(x, y){
  x + y
}

10 %fnSomar2% 15

`%fnSomar2%`(2,5)
```

------------------------------------------------------------------------

@grolemund2014

Última atualização: `r format(file.info('r_funcoes.qmd')$mtime, '%d/%m/%Y - %H:%M:%S')`