Si ndryshojnë funksionet shigjetë nga funksionet e rregullt?

Question

Accepted Answer

Funksionet shigjetë janë më të shkurta, por ndryshimet e vërteta janë në **sjelljen e lidhjes**, jo vetëm në sintaksë.

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

## Ndryshimet kryesore

**1. Nuk ka `this` të vetëm** — shigjetat trashëgojnë `this` nga përqafrimi i jashtëm. Ky është ndryshimi më i rëndësishëm dhe pse janë shumë të mirë për callback-et:

```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. Nuk ka objekti `arguments`** — përdor rest parameters në vend të tij:

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

**3. Nuk mund të përdoren si konstruktore** — `new arrow()` hedh një gabim, dhe ato nuk kanë `prototype`.

## Kur të MOS përdorësh një shigjetë

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

Mos përdor shigjetat për **metodat e objekteve** (ato nuk do të lidhen me objektin) ose kur të duhet një `this`/`arguments` dinamik (event handlers që mbështeten në `this` që është elementi).

## Pse është e rëndësishme

Përdor shigjetat për callback-et dhe funksionet e shkurta ku trashëgimi i `this` është ajo që dëshiron; përdor funksionet e rregullt për metodat, konstruktore dhe metodat e prototype-it.