¿Cuál es la diferencia entre funciones flecha y funciones normales en JavaScript?

1. Sintaxis:
   • Función normal: function myFunction() { ... }
   • Función flecha: () => { ... } o param => { ... }
2. Contexto this:
   • Función normal: this se determina por el contexto de llamada.
   • Función flecha: this se hereda léxicamente del ámbito circundante (no tiene su propio this).
3. Constructores:
   • Función normal: Puede usarse como constructor (new myFunction()).
   • Función flecha: No puede usarse como constructor.
4. Objeto arguments:
   • Función normal: Tiene su propio objeto arguments con los argumentos pasados.
   • Función flecha: No tiene su propio objeto arguments, el acceso a los argumentos se realiza mediante parámetros rest (...args).
5. Funciones nombradas:
   • Función normal: Puede ser nombrada (function myFunction() { ... }).
   • Función flecha: Por defecto anónima, se asigna a una variable para nombrarla (const myFunction = () => { ... }).
6. Retorno implícito:
   • Función normal: Requiere explícitamente return para devolver un valor (excepto en casos simples como IIFE).
   • Función flecha: En un cuerpo de una sola línea puede devolver implícitamente el resultado de una expresión sin return.

Tabla comparativa:

Característica	Función normal	Función flecha
Sintaxis	function name() { ... }	() => { ... }
Contexto this	Dinámico (según la llamada)	Léxico (del ámbito padre)
Constructor	Sí	No
Objeto arguments	Sí	No (usa parámetros rest)
Nombramiento	Puede ser nombrada	Anónima (se asigna)
Retorno implícito	No (normalmente requiere return)	Sí (para cuerpo de una línea)

// Ejemplo de funciones normales
function standardFunction() {
  console.log(this); // Depende del contexto de llamada
  console.log(arguments); // Objeto arguments disponible
}

const obj = {
  method: standardFunction
};

standardFunction(); // `this` será window (en navegador) o undefined (en modo estricto)
obj.method(); // `this` será obj
new standardFunction(); // `this` será la nueva instancia

// Ejemplo de funciones flecha
const arrowFunction = () => {
  console.log(this); // Hereda `this` del ámbito circundante (por ejemplo, Global o módulo)
  // console.log(arguments); // Error, `arguments` no disponible
};

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

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

// Retorno implícito en función flecha
const sum = (a, b) => a + b;
console.log(sum(2, 3)); // 5

// Función normal con retorno explícito
function multiply(a, b) {
  return a * b;
}
console.log(multiply(2, 3)); // 6

// La función flecha no puede ser constructora
// new arrowFunction(); // Error: TypeError: arrowFunction_1 is not a constructor