Hur skiljer sig pilformade funktioner från vanliga funktioner?

Question

Accepted Answer

Pilformade funktioner är kortare, men de verkliga skillnaderna ligger i **bindningsbeteende**, inte bara syntax.

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

## De viktigaste skillnaderna

**1. Ingen egen `this`** — pilar ärver `this` från den omgivande räckvidden. Detta är den viktigaste skillnaden och varför de är bra för callbacks:

```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. Inget `arguments`-objekt** — använd rest-parametrar istället:

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

**3. Kan inte användas som konstruktörer** — `new arrow()` kastar, och de har ingen `prototype`.

## När du INTE ska använda pilformade funktioner

```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`
};
```

Använd inte pilar för **objektmetoder** (de binder inte till objektet) eller när du behöver dynamisk `this`/`arguments` (event-hanterare som förlitar sig på att `this` är elementet).

## Varför det är viktigt

Använd pilar för callbacks och korta funktioner där arvning av `this` är vad du vill; använd vanliga funktioner för metoder, konstruktörer och prototypmetoder.