Запропонувати правку

Покращити цю статтю

Допрацюйте відповідь до «Що робить ключове слово implements?». Ваші зміни проходять модерацію перед публікацією.

Потрібне підтвердження

Контент

Що ви змінюєте

Заголовок (UA)

Коротка відповідь (UA)

Показується над повною відповіддю для швидкого нагадування.

Відповідь (UA)

## 1. Що робить `implements`

> Ключове слово `implements` каже TypeScript:
> "Цей клас **обіцяє реалізувати** всі властивості й методи,
> які описані в інтерфейсі".

Якщо клас не реалізує щось з інтерфейсу,
TypeScript видасть **помилку компіляції**.

---

### Приклад

```javascript
interface Person {
  name: string;
  greet(): void;
}

class User implements Person {
  name: string;

constructor(name: string) {
    this.name = name;
  }

greet() {
    console.log(`Привіт, ${this.name}!`);
  }
}
```

Все коректно:
Клас `User` **реалізує** інтерфейс `Person`,
тому що він містить і `name`, і `greet()`.

---

## 2. Що буде, якщо клас не реалізує все

```javascript
interface Person {
  name: string;
  greet(): void;
}

class User implements Person {
  name: string;
}

// Помилка: відсутній метод greet()
```

> TypeScript вимагатиме, щоб клас **строго відповідав інтерфейсу**,
> інакше збірка не пройде.

---

## 3. Реалізація кількох інтерфейсів

Клас може реалізувати **кілька інтерфейсів одразу**,
перелічених через кому.

```javascript
interface Flyable {
  fly(): void;
}

interface Swimmable {
  swim(): void;
}

class Duck implements Flyable, Swimmable {
  fly() {
    console.log("Летить");
  }
  swim() {
    console.log("Пливе");
  }
}
```

> Клас `Duck` зобов'язаний реалізувати **всі методи** з обох інтерфейсів.

---

## 4. Відмінність `implements` від `extends`

| Ключове слово | Де використовується | Що робить |
|---|---|---|
| `extends` | між класами або інтерфейсами | Успадковує реалізацію або структуру |
| `implements` | у класах | Гарантує реалізацію інтерфейсу (контракту) |

---

### Приклад: `extends` vs `implements`

```javascript
interface Animal {
  eat(): void;
}

interface Flyable {
  fly(): void;
}

class Bird implements Animal, Flyable {
  eat() {
    console.log("Клює зерно");
  }
  fly() {
    console.log("Летить");
  }
}

class Eagle extends Bird {
  hunt() {
    console.log("Полює");
  }
}
```

> `Bird implements Animal, Flyable` - реалізує **контракт**.
>
> `Eagle extends Bird` - **успадковує реалізацію** і додає нову.

---

## 5. `implements` перевіряє лише **типізацію**, а не поведінку

Інтерфейси в TypeScript існують **тільки під час компіляції**.
Після компіляції в JavaScript:

- ключове слово `implements` зникає;
- жодних перевірок у runtime немає.

```javascript
interface Logger {
  log(msg: string): void;
}

class ConsoleLogger implements Logger {
  log(msg: string) {
    console.log(msg);
  }
}
```

> У підсумковому JavaScript-коді немає інтерфейсу і `implements`,
> лише сам клас `ConsoleLogger`.

---

## 6. Можна реалізовувати інтерфейси з полями і методами

```javascript
interface UserData {
  id: number;
  name: string;
  getInfo(): string;
}

class User implements UserData {
  id: number;
  name: string;

constructor(id: number, name: string) {
    this.id = id;
    this.name = name;
  }

getInfo() {
    return `${this.name} (#${this.id})`;
  }
}
```

TypeScript перевірить:

- що є `id` і `name` потрібних типів;
- що є метод `getInfo()`, який повертає `string`.

---

## 7. Реалізація інтерфейсів з `readonly` і опціональними полями

```javascript
interface Config {
  readonly version: string;
  debug?: boolean;
}

class App implements Config {
  version = "1.0.0";
  // debug можна не реалізовувати, оскільки воно опціональне
}
```

> `readonly` зберігає своє значення,
> клас не зможе перевизначити властивість `version` після ініціалізації.

---

## 8. Можна реалізовувати інтерфейс, успадкований від інших

```javascript
interface Entity {
  id: number;
}

interface Timestamped {
  createdAt: Date;
}

interface User extends Entity, Timestamped {
  name: string;
}

class Admin implements User {
  id = 1;
  name = "Tim";
  createdAt = new Date();
}
```

> `Admin` реалізує **всі властивості**,
> включно з тими, що прийшли з `Entity` і `Timestamped`.

---

## 9. Можна використовувати `implements` для перевірки форми типу

TypeScript дозволяє використовувати інтерфейс як "договір" для класу,
щоб гарантувати сумісність типів, навіть без успадкування:

```javascript
interface Serializable {
  toJSON(): string;
}

class Order implements Serializable {
  constructor(public id: number, public total: number) {}
  toJSON() {
    return JSON.stringify({ id: this.id, total: this.total });
  }
}
```

---

## Підсумок

> `implements` у TypeScript використовується в класах,
> щоб **змусити клас реалізувати інтерфейс** (або кілька).
>
> Воно:
>
> - перевіряє, що клас містить усі поля і методи інтерфейсу;
> - не додає нічого в runtime (лише перевірка типів);
> - може застосовуватися до кількох інтерфейсів;
> - робить код більш строгим і передбачуваним.
>
> Відмінність від `extends`:
>
> - `extends` - **успадковує реалізацію** (код, поля, методи);
> - `implements` - **гарантує реалізацію контракту** (лише форму).

Markdown · перетягуйте зображення · ⌘B / ⌘I шорткати678 слів

Для рев’юера

Примітка для модератора (необов’язково)

Бачить лише модератор. Прискорює рев’ю.