Aprofundando sobre Funções no JavaScript: IIFE e Arguments Object.
Published: 2023-01-24 20:53:54

Recentemente analisamos a respeito das Funções de JavaScript, e vimos diversas formas de utilização, como seus escopos são lexionados e alguns exemplos práticos. No artigo de hoje, iremos citar 2 tipos de Funções que são usadas no uso intermediário:IIFE e Arguments Object



**IIFE**

IIFE (Immediately Invoked Function Expression) é uma função JavaScript que é executada imediatamente após sua criação. Isso é feito adicionando parênteses após a declaração da função. Seu modo de escrira também é diferente pois utiliza um parênteses adicional. Por exemplo:


```
//perceba o parênteses antes da `function`, indicando o uso de IIFE. 

(function () {
    var nome = "Felipe";
})();
// A variável nome não é acessível fora do escopo da expressão
```

_IIFE são criados para um uso específico._


```
(() => {
  // codigo de inicialização exemplar
  let firstVariable;
  let secondVariable;
})();

// firstVariable e secondVariable vão deixar de existir após sua execução. IIFE serve como um execute descartável.
```

Uma das vantagens de IIFE estar em mais uma parêntes, é que ele não pode ser "atrapalhado", ou chamado de maneira externa. Com isso, atribuir uma IIFE a uma variável não armazenará a função em si, mas o resultado da função.


**IIFE: Async**

Um IIFE assíncrono permite que você use `await` e `for-await` mesmo em navegadores mais antigos e tempos de execução JavaScript que não possuem await de nível superior. O operador await é usado para aguardar uma Promise e obter seu valor de cumprimento. Já o for await...of cria um loop que itera sobre objetos iteráveis ​​assíncronos, bem como iteráveis ​​sincronizados.



```
const getFileStream = async (url) => {
  // implementationconst getFileStream = async (url) => {
  // implementation
};

(async () => {
  const stream = await getFileStream("https://domain.name/path/file.ext");
  for await (const chunk of stream) {
    console.log({ chunk });
  }
})();

};

(async () => {
  const stream = await getFileStream("https://domain.name/path/file.ext");
  for await (const chunk of stream) {
    console.log({ chunk });
  }
})();

```

No caso acima,este código cria uma função assíncrona getFileStream que é chamada dentro de uma IIFE assíncrona e o retorno é armazenado em uma variável stream. Em seguida, usa um laço for await..of para iterar sobre o stream e imprimir cada pedaço no console.





**Arguments Object**


O objeto de argumentos é um objeto que contém uma lista de todos os argumentos passados ​​para a função. Ele é semelhante a um array, mas não é um array. É possível puxar os argumentos usando índices, como arguments[0], mas não é possível usar métodos de array como push, ou pop, uma grande divergência com os arrays clássicos.

Por exemplo:


```
arguments[0]
arguments[1]
arguments[2]
```
 

Nós também podemos inserir valores nos argumentos : arguments[2] = "Novo valor";

As funções não estritas que possuem apenas parâmetros simples (ou seja, sem parâmetros restantes, padrão ou desestruturados) sincronizarão o novo valor dos parâmetros com o objeto de argumentos e vice-versa:


```
function exe1(a) {
  arguments[0] = 15; 
  console.log(a);
}
exe1(5); // 15

function exe2(a) {
  a = 99; 
  console.log(arguments[0]);
}
exe2(5); // 99
```

O arguments[0] é uma referência para o primeiro argumento passado para a função e a variável a também é uma referência para arguments[0].


Com isso, concluímos nosso artigo de hoje. Em resumo, o IIFE é uma técnica útil para criar escopos privados e evitar a poluição do escopo global. O objeto arguments é uma variável especial que contém todos os argumentos passados ​​para uma função. A pilha de funções ajuda a rastrear a origem de uma chamada de função e depurar erros.

Obrigado pela leitura e até a próxima