Miben térnek el a nyíl függvények a normál függvényektől?

Question

Accepted Answer

A nyíl függvények rövidebb szintaxissal rendelkeznek, de a valódi különbségek a **binding viselkedésben** vannak, nem csak az szintaxisban.

```js
const regular = function () {};
const arrow = () => {};
const short = x => x * 2; // implicit return for one expression
```

## A fő különbségek

**1. Nincs saját `this`** — a nyíl függvények öröklik a `this`-t az azt körülvevő scope-ból. Ez a legfontosabb különbség, és ezért nagyszerűek a callback-ekhez:

```js
const timer = {
  seconds: 0,
  start() {
    setInterval(() => this.seconds++, 1000); // ✅ `this` is timer
    // a regular function here would have its own `this` (undefined) → bug
  },
};
```

**2. Nincs `arguments` objektum** — helyette a rest paramétereket használd:

```js
const sum = (...args) => args.reduce((a, b) => a + b, 0);
```

**3. Nem használhatók konstruktorként** — az `new arrow()` hibát dob, és nincs `prototype`-juk.

## Mikor NE használj nyíl függvényt

```js
const obj = {
  name: "Ann",
  greet: () => `Hi ${this.name}`, // ❌ `this` is NOT obj (it's outer scope)
  greet2() { return `Hi ${this.name}`; }, // ✅ method needs dynamic `this`
};
```

Ne használj nyíl függvényt **objektum metódusokhoz** (nem kötődnek az objektumhoz) vagy amikor dinamikus `this`/`arguments`-re van szükséged (olyan eseménykezelőkhöz, amelyek arra támaszkodnak, hogy a `this` az elem).

## Miért fontos ez

Használd a nyíl függvényeket callback-ekhez és rövid függvényekhez, ahol a `this` öröklése az, amit szeretnél; használj normál függvényeket metódusokhoz, konstruktorokhoz és prototípus metódusokhoz.