Care este diferența dintre funcțiile săgeată și funcțiile obișnuite în JavaScript?

1. Sintaxă:
   • Funcție normală: function myFunction() { ... }
   • Funcție săgeată: () => { ... } sau param => { ... }
2. Contextul this:
   • Funcție normală: this este determinat de contextul de apelare.
   • Funcție săgeată: this este moștenit lexical din mediul înconjurător (nu are propriul this).
3. Constructori:
   • Funcție normală: Poate fi folosită ca și constructor (new myFunction()).
   • Funcție săgeată: Nu poate fi folosită ca și constructor.
4. Obiectul arguments:
   • Funcție normală: Are propriul obiect arguments cu argumentele transmise.
   • Funcție săgeată: Nu are propriul obiect arguments, accesul se face prin parametri rest (...args).
5. Funcții numite:
   • Funcție normală: Poate fi numită (function myFunction() { ... }).
   • Funcție săgeată: În mod implicit anonimă, atribuită unei variabile pentru denumire (const myFunction = () => { ... }).
6. Return implicit:
   • Funcție normală: Necesită utilizarea explicită a return pentru a returna o valoare (cu excepția cazurilor simple, precum IIFE).
   • Funcție săgeată: În corpul unei singure linii poate returna implicit rezultatul expresiei fără return.

Tabel comparativ:

Caracteristică	Funcție normală	Funcție săgeată
Sintaxă	function name() { ... }	() => { ... }
Contextul this	Dinamic (în funcție de apel)	Lexical (din mediul părinte)
Constructor	Da	Nu
Obiect arguments	Da	Nu (folosește parametri rest)
Denumire	Poate fi numită	Anonim (atribuit)
Return implicit	Nu (de obicei necesită return)	Da (pentru corp de o singură linie)

// Exemplu de funcții normale
function standardFunction() {
  console.log(this); // Depinde de contextul de apel
  console.log(arguments); // Obiectul arguments disponibil
}

const obj = {
  method: standardFunction
};

standardFunction(); // `this` va fi window (în browser) sau undefined (în modul strict)
obj.method(); // `this` va fi obj
new standardFunction(); // `this` va fi noua instanță

// Exemplu de funcții săgeată
const arrowFunction = () => {
  console.log(this); // Moștenește `this` din mediul înconjurător (de exemplu, Global sau modul)
  // console.log(arguments); // Eroare, `arguments` nu este disponibil
};

const outerObj = {
  outerMethod: function() {
    const innerArrowFunction = () => {
      console.log(this); // Moștenește `this` de la outerMethod (care este outerObj)
    };
    innerArrowFunction();
  }
};

arrowFunction(); // `this` va fi window sau {} (în Node.js)
outerObj.outerMethod(); // `this` în innerArrowFunction va fi outerObj

// Return implicit în funcție săgeată
const sum = (a, b) => a + b;
console.log(sum(2, 3)); // 5

// Funcție normală cu return explicit
function multiply(a, b) {
  return a * b;
}
console.log(multiply(2, 3)); // 6

// Funcție săgeată nu poate fi constructor
// new arrowFunction(); // Eroare: TypeError: arrowFunction_1 nu este un constructor