Cum diferă funcțiile săgeată de funcțiile obișnuite?

Question

IT Interview Practice · Accepted Answer

Funcțiile săgeată sunt mai scurte, dar diferențele reale sunt în **comportamentul de binding**, nu doar în sintaxă.

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

## Diferențele cheie

**1. Nu au `this` propriu** — funcțiile săgeată moștenesc `this` din scope-ul închizător. Aceasta este cea mai importantă diferență și motivul pentru care sunt grozave pentru 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. Nu au obiectul `arguments`** — utilizați rest parameters în schimb:

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

**3. Nu pot fi utilizate ca constructori** — `new arrow()` aruncă o eroare, și nu au `prototype`.

## Când NU să utilizați o săgeată

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

Nu utilizați săgeți pentru **metodele obiectelor** (nu se vor binding la obiect) sau când aveți nevoie de un `this`/`arguments` dinamic (event handlers care se bazează pe `this` fiind elementul).

## De ce contează

Utilizați săgeți pentru callbacks și funcții scurte unde moștenirea `this` este ceea ce doriți; utilizați funcții obișnuite pentru metode, constructori și metode prototype.

Diferențele cheie

Când NU să utilizați o săgeată

De ce contează

Întrebări conexe