რა არის გვიან სტატიკური დაკავშირება (static:: vs self::)?

Question

Accepted Answer

**გვიან სტატიკური დაკავშირება** კონტროლирებს რომელი კლასი იქნება მოწოდებული სტატიკური კონტექსტში მემკვიდრეობის დროს. ძირითადი განსხვავება: **`self::`** ეხება კლასს, სადაც კოდი *დაწერილია*, ხოლო **`static::`** ეხება კლასს, რომელიც რეალურად *გამოძახდა რანტაიმზე* — რაც მნიშვნელოვანია, როდესაც შვილი კლასი ფatherის სტატიკურ მეთოდს მემკვიდრეობით იღებს.

## პრობლემა: self:: არის "ადრე დაკავშირებული"

```php
<?php
class ParentClass {
    public static function create(): self {
        return new self();      // self:: ALWAYS means ParentClass (where it's written)
    }
    public static function createStatic(): static {
        return new static();    // static:: means the CALLED class (runtime)
    }
}

class ChildClass extends ParentClass {}

get_class(ChildClass::create());        // "ParentClass" — self:: bound to where written ❌
get_class(ChildClass::createStatic());  // "ChildClass" — static:: bound to the call ✅
```

`self::` იხსნება განსაზღვრის დროს (ყოველთვის განსაზღვრული კლასი), ამიტომ მაშინაც კი, როდესაც გამოძახებული იქნება `ChildClass`-ის საშუალებით, `new self()` აკეთებს `ParentClass`-ის ინსტანციას. **`static::`** იხსნება *რანტაიმზე* რეალურად გამოძახებულ კლასამდე — ამიტომ `new static()` სწორად აკეთებს `ChildClass`-ის ინსტანციას.

## რატომ არის მნიშვნელოვანი: ფactory მეთოდები და fluent API-ები

```php
class Model {
    public static function make(): static {     // static return type + new static()
        return new static();    // ✅ returns an instance of whatever subclass called it
    }
}
class User extends Model {}
class Post extends Model {}

User::make();   // returns a User (not a Model) — thanks to late static binding
Post::make();   // returns a Post
```

გვიან სტატიკური დაკავშირება არის ის, რაც მემკვიდრეობით მიღებულ ფactory მეთოდებს, fluent builders-ებს და ORM pattern-ებს აშ *სწორი ქვეკლასის* ინსტანციის დაბრუნება — აუცილებელი static-მეთოდ-ძირითადი API-ებისთვის, რომელზეც ფреიმვორკები დამოკიდებულია.

## სამი საკვანძო სიტყვა

```text
self::    → the class where the code is WRITTEN (early/static binding)
static::  → the class CALLED at runtime (late static binding) — for subclass-aware code
parent::  → the parent class (for calling overridden parent methods)
```

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

გვიან სტატიკური დაკავშირება (`static::` vs `self::``) არის მნიშვნელოვანი და ხშირად გაუგებელი PHP კონცეფცია, განსაკუთრებით აქტუალური მემკვიდრეობა-ძირითადი სტატიკური API-ების ფრეიმვორკებით განხორციელების გასაგებად.

კრიტიკული განსხვავება — რომ **`self::` დაკავშირებული იქნება კლასთან, სადაც კოდი დაწერილია** ხოლო **`static::` დაკავშირებული იქნება კლასთან, რომელიც რეალურად გამოძახდა რანტაიმზე** — მნიშვნელოვანია, როდესაც შვილი კლასი ფatherის სტატიკურ მეთოდს მემკვიდრეობით იღებს, რომელიც ინსტანციებს აკეთებს ან კლასს მოწოდებს: `self::`-ით, მემკვიდრეობით მიღებული ფactory მეთოდები ყოველთვის ფatherის ტიპს დაბრუნებდიდნენ (ხარვეზი), ხოლო **`static::` სწორად დაბრუნებს გამოძახებულ ქვეკლასს**.

ეს ზუსტად ის, რაც ხელმისაწვდომს აკეთებს მემკვიდრეობით მიღებულ ფactory მეთოდებს, fluent builders-ებს და ORM pattern-ებს, რომელზეც ფრეიმვორკები, როგორიცაა Laravel-ის Eloquent, დამოკიდებული არიან (მაგ. `User::make()` დაბრუნებული `User`, არა base `Model`).

გვიან სტატიკური დაკავშირების გაგება მნიშვნელოვანია როგორც ამ ფრეიმვორკ pattern-ების სწორად გამოყენებისთვის, ასევე თქვენი საკუთარი მემკვიდრეობა-ცნობიერი სტატიკური მეთოდების დაწერისთვის, რომლებიც ქვეკლასებთან სწორად იქცევიან.

მინდობის უფრო მაღალი თემა რომ იყოს, ეს არის დახვეწილი ხარვეზების და დაბნევის ხშირი წყარო ("რატომ აბრუნებს ეს ფatherის კლასს?"), და `self::`/`static::`/`parent::` განსხვავების გაგება ასახავს PHP-ის ობიექტური მოდელის და მემკვიდრეობის ქცევის უფრო ღრმა ცოდნას — ღირებული თანამედროვე PHP ფრეიმვორკებში გავრცელებული static-მეთოდ-ძირითადი, მემკვიდრეობა-მძიმე API-ებთან მუშაობისთვის.