Hvordan adskiller pilefunktioner sig fra almindelige funktioner?

Question

Accepted Answer

Pilefunktioner er kortere, men de rigtige forskelle ligger i **bindingsadfærd**, ikke bare i syntaks.

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

## De vigtigste forskelle

**1. Ingen egen `this`** — pilefunktioner arver `this` fra det omgivende scope. Dette er den vigtigste forskel og hvorfor de er fantastiske til 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. Intet `arguments`-objekt** — brug rest-parametre i stedet:

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

**3. Kan ikke bruges som konstruktorer** — `new arrow()` kaster, og de har ingen `prototype`.

## Hvornår skal man IKKE bruge pilefunktioner

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

Brug ikke pilefunktioner til **objektmetoder** (de vil ikke binde til objektet) eller når du har brug for en dynamisk `this`/`arguments` (eventhandlere, der er afhængige af `this` værende elementet).

## Hvorfor det betyder noget

Brug pilefunktioner til callbacks og korte funktioner, hvor arv af `this` er det, du ønsker; brug almindelige funktioner til metoder, konstruktorer og prototypemetoder.