Mi a különbség a nyílfüggvények és a normál függvények között JavaScriptben?

1. Szintaxis:
   • Általános függvény: function myFunction() { ... }
   • Nyíl függvény: () => { ... } vagy param => { ... }
2. this kontextus:
   • Általános függvény: A this a hívás kontextusától függ.
   • Nyíl függvény: A this lexikusan öröklődik a környező szcénából (nem rendelkezik saját this-el).
3. Konstruktorok:
   • Általános függvény: Használható konstruktorként (new myFunction()).
   • Nyíl függvény: Nem használható konstruktorként.
4. arguments objektum:
   • Általános függvény: Saját arguments objektummal rendelkezik.
   • Nyíl függvény: Nincs saját arguments-a, az argumentumokhoz a rest paraméterek (...args) segítségével lehet hozzáférni.
5. Nevezett függvények:
   • Általános függvény: Nevezhető (function myFunction() { ... }).
   • Nyíl függvény: Alapértelmezés szerint névtelen, változóhoz rendelve nevezik (const myFunction = () => { ... }).
6. Implicit visszatérés:
   • Általános függvény: Kifejezetten return-t igényel a visszatéréshez.
   • Nyíl függvény: Egysoros test esetén implicit visszatér a kifejezés eredményével.

Összehasonlító táblázat:

Jellemző	Általános függvény	Nyíl függvény
Szintaxis	function name() { ... }	() => { ... }
this kontextus	Dinamikus (hívási kontextus)	Lexikusan öröklött (szülői környezetből)
Konstruktor	Igen	Nem
arguments objektum	Igen	Nem (rest paraméterekkel)
Névvel ellátott függvény	Igen	Név nélküli (hozzárendelve)
Implicit visszatérés	Nem (általában return szükséges)	Igen (egysoros test esetén)

// Példák általános függvényekre
function standardFunction() {
  console.log(this); // A hívási kontextustól függ
  console.log(arguments); // Az arguments objektum elérhető
}

const obj = {
  method: standardFunction
};

standardFunction(); // this a window vagy undefined
obj.method(); // this az obj
new standardFunction(); // this az új példány

// Nyíl függvény példák
const arrowFunction = () => {
  console.log(this); // A szülő környezetből öröklődik
  // console.log(arguments); // Hiba, nincs arguments
};

const outerObj = {
  outerMethod: function() {
    const innerArrowFunction = () => {
      console.log(this); // az outerMethod-ből öröklődik (outerObj)
    };
    innerArrowFunction();
  }
};

arrowFunction(); // this a window vagy {} (Node.js)
outerObj.outerMethod(); // innerArrowFunction-ben this az outerObj

// Implicit visszatérés nyíl függvényben
const sum = (a, b) => a + b;
console.log(sum(2, 3)); // 5

// Általános függvény explicit visszatéréssel
function multiply(a, b) {
  return a * b;
}
console.log(multiply(2, 3)); // 6

// Nyíl függvény nem lehet konstruktor
// new arrowFunction(); // Hiba: TypeError