Qual é a diferença entre funções de seta e funções normais em JavaScript?

1. Sintaxe:
   • Função normal: function myFunction() { ... }
   • Função seta: () => { ... } ou param => { ... }
2. Contexto this:
   • Função normal: this é determinado pelo contexto de chamada.
   • Função seta: this é herdado lexicalmente do escopo circundante (não tem seu próprio this).
3. Construtores:
   • Função normal: Pode ser usada como construtor (new myFunction()).
   • Função seta: Não pode ser usada como construtor.
4. Objeto arguments:
   • Função normal: Possui seu próprio objeto arguments contendo os argumentos passados.
   • Função seta: Não possui seu próprio objeto arguments, o acesso aos argumentos é feito através de parâmetros rest (...args).
5. Funções nomeadas:
   • Função normal: Pode ser nomeada (function myFunction() { ... }).
   • Função seta: Por padrão anônima, atribuída a uma variável para nomear (const myFunction = () => { ... }).
6. Retorno implícito:
   • Função normal: Requer explicitamente return para retornar um valor (exceto em casos simples como IIFE).
   • Função seta: Em corpo de uma única linha, pode retornar implicitamente o resultado de uma expressão sem return.

Tabela comparativa:

Característica	Função normal	Função seta
Sintaxe	function name() { ... }	() => { ... }
Contexto this	Dinâmico (segundo a chamada)	Léxico (do escopo pai)
Construtor	Sim	Não
Objeto arguments	Sim	Não (usa parâmetros rest)
Nomeação	Pode ser nomeada	Anônima (atribui-se)
Retorno implícito	Não (normalmente requer return)	Sim (para corpo de uma linha)

// Exemplo de funções normais
function standardFunction() {
  console.log(this); // Depende do contexto de chamada
  console.log(arguments); // Objeto arguments disponível
}

const obj = {
  method: standardFunction
};

standardFunction(); // `this` será window (no navegador) ou undefined (modo estrito)
obj.method(); // `this` será obj
new standardFunction(); // `this` será a nova instância

// Exemplo de funções seta
const arrowFunction = () => {
  console.log(this); // Herda `this` do escopo circundante (por exemplo, Global ou módulo)
  // console.log(arguments); // Erro, `arguments` não disponível
};

const outerObj = {
  outerMethod: function() {
    const innerArrowFunction = () => {
      console.log(this); // Herda `this` de outerMethod (que é outerObj)
    };
    innerArrowFunction();
  }
};

arrowFunction(); // `this` será window (no navegador) ou {} (em Node.js)
outerObj.outerMethod(); // `this` dentro de innerArrowFunction será outerObj

// Retorno implícito em função seta
const sum = (a, b) => a + b;
console.log(sum(2, 3)); // 5

// Função normal com retorno explícito
function multiply(a, b) {
  return a * b;
}
console.log(multiply(2, 3)); // 6

// A função seta não pode ser construtora
// new arrowFunction(); // Erro: TypeError: arrowFunction_1 não é um construtor