რა არის სერვისები და დამოკიდებულების ინჯექცია Angular-ში?

Question

IT Interview Practice · Accepted Answer

**სერვისი** არის კლასი **არა-UI ლოგიკისთვის** — მონაცემების ჩამოტვირთვა, ბიზნეს წესები, გაზიარებული მდგომარეობა, ლოგირება — რომელსაც კომპონენტები შეუძლია გამოიყენონ. **დამოკიდებულების ინჯექცია (DI)** არის ის, როგორ **უზრუნველყოფს** Angular ეს სერვისები კომპონენტებს, რომლებიც მათ სჭირდებათ, ის კი რომ კომპონენტები მათ ხელით არ შექმნიდნენ.

## სერვისის განსაზღვრა

```ts
import { Injectable } from "@angular/core";

@Injectable({ providedIn: "root" }) // makes it a singleton available app-wide
export class UserService {
  private users = [];
  getUsers() { return this.users; }
  addUser(u) { this.users.push(u); }
}
```

`@Injectable({ providedIn: "root" })` დეკორატორი ჯამბს Angular-ის DI სისტემაში ერთი გაზიარებული ინსტანციის (singleton) სახით მთელი აპლიკაციისთვის.

## ის კომპონენტში ინჯექცია

```ts
@Component({ ... })
export class UserListComponent {
  // Angular sees this constructor param and INJECTS the singleton automatically
  constructor(private userService: UserService) {}

users = this.userService.getUsers(); // just use it
}
```

თქვენ უბრალოდ აცხადებთ სერვისს კონსტრუქტორის პარამეტრად; Angular-ის DI **შექმნის და მიაწვდის** ინსტანციას. თქვენ არასოდეს დაწერთ `new UserService()`. (თანამედროვე Angular ასევე შეუძლია გამოიყენოს `inject()` ფუნქცია კონსტრუქტორის ინჯექციის ნაცვლად.)

```ts
import { inject } from "@angular/core";
export class UserListComponent {
  private userService = inject(UserService); // alternative injection style
}
```

## რატომ არის DI ღირებული

```text
✓ Single source of truth — one shared UserService instance across components
✓ Loose coupling — components depend on the type, not on constructing it
✓ Testability — swap in a mock service in tests easily
✓ Lifecycle management — Angular handles creation and sharing
```

ვინაიდან კომპონენტი არ აკონსტრუირებს თავის დამოკიდებულებებს, თქვენ შეგიძლიათ ინჯექცია გააკეთოთ **ყალბი** სერვისი ტესტებში, ან შეცვალოთ განხორციელება მთელ აპლიკაციაში ერთ ადგილში.

## რატომ აქვს მნიშვნელობა

სერვისები + DI არის Angular არქიტექტურის ცენტრალური: კომპონენტები რჩებიან UI-ზე ფოკუსირებული, სერვისები ინახავს ლოგიკას და მდგომარეობას, ხოლო DI ამათ აკავშირებს მინიმალური დაკავშირებით.

ეს გამიჯვნა (და მაშ გამოსწავლებულობა, რომელსაც ის მოაქვს) არის Angular-ის განმარტებული სიძლიერე — ასესხებული ბეკენდ ფრეიმვორკებიდან — და `@Injectable({ providedIn: 'root' })` არის ყოველდღიური შაბლონი გაზიარებული, ინჯექციადი singleton-ისთვის.

სერვისის განსაზღვრა

ის კომპონენტში ინჯექცია

რატომ არის DI ღირებული

რატომ აქვს მნიშვნელობა

დაკავშირებული კითხვები